






"""simple docstring"""



import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import MaskaFormerConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch

						from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel

						if is_vision_available():
												from transformers import MaskaFormerImageProcessor

if is_vision_available():
						from PIL import Image





class 					_UpperCAmelCase       :




					def __init__(				self     :						List[str]    ,						A     :						List[str]    ,						A     :						List[str]=2    ,						A     :						Tuple=True    ,						A     :						Union[str, Any]=False    ,						A     :						Optional[int]=10    ,						A     :						Dict=3    ,						A     :						Union[str, Any]=32 * 8    ,						A     :						Union[str, Any]=32 * 8    ,						A     :						Optional[int]=4    ,						A     :						Any=64    ,						)  ->  str:
							lowercase_ : List[str]							       =   parent
							lowercase_ : Any							       =   batch_size
							lowercase_ : Union[str, Any]							       =   is_training
							lowercase_ : Optional[Any]							       =   use_auxiliary_loss
							lowercase_ : List[Any]							       =   num_queries
							lowercase_ : Any							       =   num_channels
							lowercase_ : Tuple							       =   min_size
							lowercase_ : List[str]							       =   max_size
							lowercase_ : str							       =   num_labels
							lowercase_ : Tuple							       =   hidden_dim
							lowercase_ : int							       =   hidden_dim




					def   A  (				self     :						int   )  ->  Dict:
							lowercase_ : Union[str, Any]							       =   floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]   ).to(
							    A   )

							lowercase_ : Dict							       =   torch.ones([self.batch_size, self.min_size, self.max_size]    ,						device=A   )

							lowercase_ : Tuple							       =   (
							    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]    ,						device=A   ) > 0.5
							).float()
							lowercase_ : Optional[int]							       =   (torch.rand((self.batch_size, self.num_labels)    ,						device=A   ) > 0.5).long()

							lowercase_ : List[str]							       =   self.get_config()
							return config, pixel_values, pixel_mask, mask_labels, class_labels




					def   A  (				self     :						Optional[int]   )  ->  Optional[Any]:
							lowercase_ : Optional[Any]							       =   MaskaFormerConfig(
							    hidden_size=self.hidden_dim    ,						)
							lowercase_ : str							       =   self.num_queries
							lowercase_ : Dict							       =   self.num_labels

							lowercase_ : Union[str, Any]							       =   [1, 1, 1, 1]
							lowercase_ : Tuple							       =   self.num_channels

							lowercase_ : int							       =   64
							lowercase_ : Optional[Any]							       =   1_28
							lowercase_ : int							       =   self.hidden_dim
							lowercase_ : List[Any]							       =   self.hidden_dim
							lowercase_ : Union[str, Any]							       =   self.hidden_dim
							return config




					def   A  (				self     :						Optional[int]   )  ->  Dict:
							lowercase_       ,					lowercase_       ,					lowercase_       ,					lowercase_       ,					lowercase_ : List[Any]							       =   self.prepare_config_and_inputs()
							lowercase_ : List[str]							       =   {'''pixel_values''': pixel_values, '''pixel_mask''': pixel_mask}
							return config, inputs_dict




					def   A  (				self     :						List[Any]    ,						A     :						int    ,						A     :						int   )  ->  Tuple:
							lowercase_ : List[str]							       =   output.encoder_hidden_states
							lowercase_ : Tuple							       =   output.pixel_decoder_hidden_states
							lowercase_ : int							       =   output.transformer_decoder_hidden_states

							self.parent.assertTrue(len(A   )    ,						len(config.backbone_config.depths   )   )
							self.parent.assertTrue(len(A   )    ,						len(config.backbone_config.depths   )   )
							self.parent.assertTrue(len(A   )    ,						config.decoder_layers   )




					def   A  (				self     :						Any    ,						A     :						Optional[Any]    ,						A     :						Optional[Any]    ,						A     :						int    ,						A     :						int=False   )  ->  Union[str, Any]:
							with torch.no_grad():
									lowercase_ : List[Any]							       =   MaskaFormerModel(config=A   )
									model.to(A   )
									model.eval()

									lowercase_ : Any							       =   model(pixel_values=A    ,						pixel_mask=A   )
									lowercase_ : Tuple							       =   model(A    ,						output_hidden_states=A   )

							self.parent.assertEqual(
							    output.transformer_decoder_last_hidden_state.shape    ,						(self.batch_size, self.num_queries, self.hidden_dim)    ,						)
							# let's ensure the other two hidden state exists
							self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None   )
							self.parent.assertTrue(output.encoder_last_hidden_state is not None   )

							if output_hidden_states:
									self.check_output_hidden_state(A    ,						A   )






					def   A  (				self     :						Optional[int]    ,						A     :						Union[str, Any]    ,						A     :						Tuple    ,						A     :						str    ,						A     :						Optional[Any]    ,						A     :						Tuple   )  ->  Optional[Any]:
							lowercase_ : Union[str, Any]							       =   MaskaFormerForUniversalSegmentation(config=A   )
							model.to(A   )
							model.eval()

							def comm_check_on_output(A     :						List[Any]   ):
									# let's still check that all the required stuff is there
									self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None   )
									self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None   )
									self.parent.assertTrue(result.encoder_last_hidden_state is not None   )
									# okay, now we need to check the logits shape
									# due to the encoder compression, masks have a //4 spatial size
									self.parent.assertEqual(
									    result.masks_queries_logits.shape    ,						(self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4)    ,						)
									# + 1 for null class
									self.parent.assertEqual(
									    result.class_queries_logits.shape    ,						(self.batch_size, self.num_queries, self.num_labels + 1)   )

							with torch.no_grad():
									lowercase_ : Dict							       =   model(pixel_values=A    ,						pixel_mask=A   )
									lowercase_ : Dict							       =   model(A   )

									comm_check_on_output(A   )

									lowercase_ : str							       =   model(
									    pixel_values=A    ,						pixel_mask=A    ,						mask_labels=A    ,						class_labels=A   )

							comm_check_on_output(A   )

							self.parent.assertTrue(result.loss is not None   )
							self.parent.assertEqual(result.loss.shape    ,						torch.Size([1]   )   )





@require_torch
class 					_UpperCAmelCase       ( _A   ,						_A   ,						unittest.TestCase							):
					SCREAMING_SNAKE_CASE_		:				Tuple							    =   (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
					SCREAMING_SNAKE_CASE_		:				Optional[int]							    =   {"feature-extraction": MaskaFormerModel} if is_torch_available() else {}

					SCREAMING_SNAKE_CASE_		:				Tuple							    =   False
					SCREAMING_SNAKE_CASE_		:				Union[str, Any]							    =   False
					SCREAMING_SNAKE_CASE_		:				Union[str, Any]							    =   False
					SCREAMING_SNAKE_CASE_		:				int							    =   False




					def   A  (				self     :						Dict   )  ->  Dict:
							lowercase_ : Any							       =   MaskaFormerModelTester(self   )
							lowercase_ : Union[str, Any]							       =   ConfigTester(self    ,						config_class=A    ,						has_text_modality=A   )




					def   A  (				self     :						Union[str, Any]   )  ->  List[str]:
							self.config_tester.run_common_tests()




					def   A  (				self     :						Optional[Any]   )  ->  Optional[Any]:
							lowercase_       ,					lowercase_ : Optional[int]							       =   self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.create_and_check_maskaformer_model(A    ,						**A    ,						output_hidden_states=A   )




					def   A  (				self     :						List[str]   )  ->  Any:
							lowercase_ : Dict							       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*A   )




					@unittest.skip(reason='''Mask2Former does not use inputs_embeds'''   )
					def   A  (				self     :						Dict   )  ->  List[Any]:
							pass




					@unittest.skip(reason='''Mask2Former does not have a get_input_embeddings method'''   )
					def   A  (				self     :						Union[str, Any]   )  ->  Optional[Any]:
							pass




					@unittest.skip(reason='''Mask2Former is not a generative model'''   )
					def   A  (				self     :						int   )  ->  List[Any]:
							pass




					@unittest.skip(reason='''Mask2Former does not use token embeddings'''   )
					def   A  (				self     :						Tuple   )  ->  Union[str, Any]:
							pass




					@require_torch_multi_gpu
					@unittest.skip(
					    reason='''Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''   )
					def   A  (				self     :						Dict   )  ->  List[str]:
							pass




					@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''   )
					def   A  (				self     :						Tuple   )  ->  int:
							pass




					def   A  (				self     :						Optional[int]   )  ->  int:
							lowercase_       ,					lowercase_ : Tuple							       =   self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
									lowercase_ : List[str]							       =   model_class(A   )
									lowercase_ : int							       =   inspect.signature(model.forward   )
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									lowercase_ : Any							       =   [*signature.parameters.keys()]

									lowercase_ : Optional[Any]							       =   ['''pixel_values''']
									self.assertListEqual(arg_names[:1]    ,						A   )




					@slow
					def   A  (				self     :						Tuple   )  ->  Optional[Any]:
							for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
									lowercase_ : Tuple							       =   MaskaFormerModel.from_pretrained(A   )
									self.assertIsNotNone(A   )




					def   A  (				self     :						Tuple   )  ->  List[Any]:
							lowercase_ : Dict							       =   (self.model_tester.min_size,) * 2
							lowercase_ : Optional[Any]							       =   {
							    '''pixel_values''': torch.randn((2, 3, *size)    ,						device=A   ),
							    '''mask_labels''': torch.randn((2, 10, *size)    ,						device=A   ),
							    '''class_labels''': torch.zeros(2    ,						10    ,						device=A   ).long(),
							}
							lowercase_ : int							       =   self.model_tester.get_config()

							lowercase_ : str							       =   MaskaFormerForUniversalSegmentation(A   ).to(A   )
							lowercase_ : Optional[int]							       =   model(**A   )
							self.assertTrue(outputs.loss is not None   )




					def   A  (				self     :						str   )  ->  List[str]:
							lowercase_       ,					lowercase_ : Optional[Any]							       =   self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.create_and_check_maskaformer_model(A    ,						**A    ,						output_hidden_states=A   )




					def   A  (				self     :						List[Any]   )  ->  Optional[int]:
							lowercase_       ,					lowercase_ : str							       =   self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
									lowercase_ : List[str]							       =   model_class(A   ).to(A   )
									lowercase_ : Any							       =   model(**A    ,						output_attentions=A   )
									self.assertTrue(outputs.attentions is not None   )




					def   A  (				self     :						int   )  ->  str:
							if not self.model_tester.is_training:
									return

							lowercase_ : Any							       =   self.all_model_classes[1]
							lowercase_       ,					lowercase_       ,					lowercase_       ,					lowercase_       ,					lowercase_ : List[str]							       =   self.model_tester.prepare_config_and_inputs()

							lowercase_ : Tuple							       =   model_class(A   )
							model.to(A   )
							model.train()

							lowercase_ : Optional[int]							       =   model(A    ,						mask_labels=A    ,						class_labels=A   ).loss
							loss.backward()






					def   A  (				self     :						Any   )  ->  Union[str, Any]:
							lowercase_ : Optional[int]							       =   self.all_model_classes[1]
							lowercase_       ,					lowercase_       ,					lowercase_       ,					lowercase_       ,					lowercase_ : Optional[int]							       =   self.model_tester.prepare_config_and_inputs()
							lowercase_ : int							       =   True
							lowercase_ : Tuple							       =   True

							lowercase_ : List[str]							       =   model_class(A   ).to(A   )
							model.train()

							lowercase_ : Dict							       =   model(A    ,						mask_labels=A    ,						class_labels=A   )

							lowercase_ : Optional[Any]							       =   outputs.encoder_hidden_states[0]
							encoder_hidden_states.retain_grad()

							lowercase_ : str							       =   outputs.pixel_decoder_hidden_states[0]
							pixel_decoder_hidden_states.retain_grad()

							lowercase_ : List[str]							       =   outputs.transformer_decoder_hidden_states[0]
							transformer_decoder_hidden_states.retain_grad()

							lowercase_ : Union[str, Any]							       =   outputs.attentions[0]
							attentions.retain_grad()

							outputs.loss.backward(retain_graph=A   )

							self.assertIsNotNone(encoder_hidden_states.grad   )
							self.assertIsNotNone(pixel_decoder_hidden_states.grad   )
							self.assertIsNotNone(transformer_decoder_hidden_states.grad   )
							self.assertIsNotNone(attentions.grad   )
__A		:       Any  				=		1E-4



def 						lowercase    (				):
		lowercase_ : Optional[int]							       =   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
		return image






@require_vision
@slow
class 					_UpperCAmelCase       ( unittest.TestCase							):




					@cached_property
					def   A  (				self     :						Optional[int]   )  ->  str:
							return "facebook/mask2former-swin-small-coco-instance"




					@cached_property
					def   A  (				self     :						Optional[int]   )  ->  List[str]:
							return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints   ) if is_vision_available() else None




					def   A  (				self     :						Tuple   )  ->  Tuple:
							lowercase_ : Optional[Any]							       =   MaskaFormerModel.from_pretrained(self.model_checkpoints   ).to(A   )
							lowercase_ : Any							       =   self.default_image_processor
							lowercase_ : int							       =   prepare_img()
							lowercase_ : Optional[int]							       =   image_processor(A    ,						return_tensors='''pt'''   ).to(A   )
							lowercase_ : Dict							       =   inputs['''pixel_values'''].shape
							# check size is divisible by 32
							self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0   )
							# check size
							self.assertEqual(A    ,						(1, 3, 3_84, 3_84)   )

							with torch.no_grad():
									lowercase_ : Dict							       =   model(**A   )

							lowercase_ : List[str]							       =   torch.tensor(
							    [[-0.2790, -1.0717, -1.1668], [-0.5128, -0.3128, -0.4987], [-0.5832, 0.1971, -0.0197]]   ).to(A   )
							self.assertTrue(
							    torch.allclose(
							        outputs.encoder_last_hidden_state[0, 0, :3, :3]    ,						A    ,						atol=A   )   )

							lowercase_ : str							       =   torch.tensor(
							    [[0.8973, 1.1847, 1.1776], [1.1934, 1.5040, 1.5128], [1.1153, 1.4486, 1.4951]]   ).to(A   )
							self.assertTrue(
							    torch.allclose(
							        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]    ,						A    ,						atol=A   )   )

							lowercase_ : Tuple							       =   torch.tensor(
							    [[2.1152, 1.7000, -0.8603], [1.5808, 1.8004, -0.9353], [1.6043, 1.7495, -0.5999]]   ).to(A   )
							self.assertTrue(
							    torch.allclose(
							        outputs.transformer_decoder_last_hidden_state[0, :3, :3]    ,						A    ,						atol=A   )   )




					def   A  (				self     :						Union[str, Any]   )  ->  Dict:
							lowercase_ : List[Any]							       =   MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints   ).to(A   ).eval()
							lowercase_ : Optional[int]							       =   self.default_image_processor
							lowercase_ : List[str]							       =   prepare_img()
							lowercase_ : List[Any]							       =   image_processor(A    ,						return_tensors='''pt'''   ).to(A   )
							lowercase_ : Any							       =   inputs['''pixel_values'''].shape
							# check size is divisible by 32
							self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0   )
							# check size
							self.assertEqual(A    ,						(1, 3, 3_84, 3_84)   )

							with torch.no_grad():
									lowercase_ : List[Any]							       =   model(**A   )
							# masks_queries_logits
							lowercase_ : Union[str, Any]							       =   outputs.masks_queries_logits
							self.assertEqual(
							    masks_queries_logits.shape    ,						(1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)   )
							lowercase_ : Optional[int]							       =   [
							    [-8.7839, -9.0056, -8.8121],
							    [-7.4104, -7.0313, -6.5401],
							    [-6.6105, -6.3427, -6.4675],
							]
							lowercase_ : str							       =   torch.tensor(A   ).to(A   )
							self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]    ,						A    ,						atol=A   )   )
							# class_queries_logits
							lowercase_ : List[str]							       =   outputs.class_queries_logits
							self.assertEqual(class_queries_logits.shape    ,						(1, model.config.num_queries, model.config.num_labels + 1)   )
							lowercase_ : Optional[Any]							       =   torch.tensor(
							    [
							        [1.8324, -8.0835, -4.1922],
							        [0.8450, -9.0050, -3.6053],
							        [0.3045, -7.7293, -3.0275],
							    ]   ).to(A   )
							self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]    ,						A    ,						atol=A   )   )






					def   A  (				self     :						Union[str, Any]   )  ->  Tuple:
							lowercase_ : List[Any]							       =   MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints   ).to(A   ).eval()
							lowercase_ : List[str]							       =   self.default_image_processor

							lowercase_ : Union[str, Any]							       =   image_processor(
							    [np.zeros((3, 8_00, 13_33)   ), np.zeros((3, 8_00, 13_33)   )]    ,						segmentation_maps=[np.zeros((3_84, 3_84)   ).astype(np.floataa   ), np.zeros((3_84, 3_84)   ).astype(np.floataa   )]    ,						return_tensors='''pt'''    ,						)

							lowercase_ : Optional[int]							       =   inputs['''pixel_values'''].to(A   )
							lowercase_ : Union[str, Any]							       =   [el.to(A   ) for el in inputs['''mask_labels''']]
							lowercase_ : str							       =   [el.to(A   ) for el in inputs['''class_labels''']]

							with torch.no_grad():
									lowercase_ : List[Any]							       =   model(**A   )

							self.assertTrue(outputs.loss is not None   )





def  lowerCAmelCase__			(  SCREAMING_SNAKE_CASE_     )				->		list:

			if len(SCREAMING_SNAKE_CASE_     ) <= 1:
						return [tuple(SCREAMING_SNAKE_CASE_     )]

			lowerCAmelCase__      :      Optional[Any]         =		[]

			def generate(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_     ):
						if k == 1:
									res.append(tuple(arr[:]     )     )
									return

						generate(k - 1       ,							SCREAMING_SNAKE_CASE_     )

						for i in range(k - 1     ):
									if k % 2 == 0:  # k is even
												lowerCAmelCase__      ,				lowerCAmelCase__      :      str         =		arr[k - 1], arr[i]
									else:  # k is odd
												lowerCAmelCase__      ,				lowerCAmelCase__      :      Union[str, Any]         =		arr[k - 1], arr[0]
									generate(k - 1       ,							SCREAMING_SNAKE_CASE_     )

			generate(len(SCREAMING_SNAKE_CASE_     )       ,							SCREAMING_SNAKE_CASE_     )
			return res


if __name__ == "__main__":
					lowerCamelCase__          =		input("""Enter numbers separated by a comma:\n""").strip()
					lowerCamelCase__          =		[int(item) for item in user_input.split(""",""")]
					print(heaps(arr))