





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


						def __init__( self			:       List[str]					,	UpperCamelCase__			:       Optional[int]					,	UpperCamelCase__			:       Optional[Any]=2					,	UpperCamelCase__			:       str=True					,	UpperCamelCase__			:       Dict=False					,	UpperCamelCase__			:       Optional[Any]=10					,	UpperCamelCase__			:       Optional[int]=3					,	UpperCamelCase__			:       str=32 * 8					,	UpperCamelCase__			:       Any=32 * 8					,	UpperCamelCase__			:       Tuple=4					,	UpperCamelCase__			:       Optional[Any]=64					,	):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					List[str]           =							parent
												SCREAMING_SNAKE_CASE							:					int           =							batch_size
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							is_training
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							use_auxiliary_loss
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							num_queries
												SCREAMING_SNAKE_CASE							:					Dict           =							num_channels
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							min_size
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							max_size
												SCREAMING_SNAKE_CASE							:					Any           =							num_labels
												SCREAMING_SNAKE_CASE							:					List[Any]           =							hidden_dim
												SCREAMING_SNAKE_CASE							:					List[Any]           =							hidden_dim


						def  __A ( self			:       Any		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					List[str]           =							floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]		).to(
												    A__		)

												SCREAMING_SNAKE_CASE							:					List[Any]           =							torch.ones([self.batch_size, self.min_size, self.max_size]					,	device=A__		)

												SCREAMING_SNAKE_CASE							:					Any           =							(
												    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]					,	device=A__		) > 0.5
												).float()
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							(torch.rand((self.batch_size, self.num_labels)					,	device=A__		) > 0.5).long()

												SCREAMING_SNAKE_CASE							:					Dict           =							self.get_config()
												return config, pixel_values, pixel_mask, mask_labels, class_labels


						def  __A ( self			:       Optional[Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Tuple           =							MaskaFormerConfig(
												    hidden_size=self.hidden_dim					,	)
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							self.num_queries
												SCREAMING_SNAKE_CASE							:					Dict           =							self.num_labels

												SCREAMING_SNAKE_CASE							:					Tuple           =							[1, 1, 1, 1]
												SCREAMING_SNAKE_CASE							:					List[str]           =							self.num_channels

												SCREAMING_SNAKE_CASE							:					Optional[int]           =							64
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							128
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							self.hidden_dim
												SCREAMING_SNAKE_CASE							:					List[Any]           =							self.hidden_dim
												SCREAMING_SNAKE_CASE							:					str           =							self.hidden_dim
												return config


						def  __A ( self			:       Optional[Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE							:					Any           =							self.prepare_config_and_inputs()
												SCREAMING_SNAKE_CASE							:					Tuple           =							{'''pixel_values''': pixel_values, '''pixel_mask''': pixel_mask}
												return config, inputs_dict


						def  __A ( self			:       List[str]					,	UpperCamelCase__			:       Any					,	UpperCamelCase__			:       List[Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					str           =							output.encoder_hidden_states
												SCREAMING_SNAKE_CASE							:					int           =							output.pixel_decoder_hidden_states
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							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			:       Dict					,	UpperCamelCase__			:       Tuple					,	UpperCamelCase__			:       List[str]					,	UpperCamelCase__			:       Union[str, Any]					,	UpperCamelCase__			:       Tuple=False		):





												'''simple docstring'''





												with torch.no_grad():
																		SCREAMING_SNAKE_CASE							:					Tuple           =							MaskaFormerModel(config=A__		)
																		model.to(A__		)
																		model.eval()

																		SCREAMING_SNAKE_CASE							:					List[Any]           =							model(pixel_values=A__					,	pixel_mask=A__		)
																		SCREAMING_SNAKE_CASE							:					int           =							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]					,	UpperCamelCase__			:       str					,	UpperCamelCase__			:       Optional[int]					,	UpperCamelCase__			:       str					,	UpperCamelCase__			:       List[str]					,	UpperCamelCase__			:       Union[str, Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Tuple           =							MaskaFormerForUniversalSegmentation(config=A__		)
												model.to(A__		)
												model.eval()

												def comm_check_on_output(UpperCamelCase__			:       str		):
																		# 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():
																		SCREAMING_SNAKE_CASE							:					Tuple           =							model(pixel_values=A__					,	pixel_mask=A__		)
																		SCREAMING_SNAKE_CASE							:					Dict           =							model(A__		)

																		comm_check_on_output(A__		)

																		SCREAMING_SNAKE_CASE							:					Optional[int]           =							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       lowercase__		(     __a			,							__a			,							unittest.TestCase):
						UpperCamelCase_  =	(MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
						UpperCamelCase_  =	{"""feature-extraction""": MaskaFormerModel} if is_torch_available() else {}

						UpperCamelCase_  =	False
						UpperCamelCase_  =	False
						UpperCamelCase_  =	False
						UpperCamelCase_  =	False


						def  __A ( self			:       Dict		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							MaskaFormerModelTester(self		)
												SCREAMING_SNAKE_CASE							:					Any           =							ConfigTester(self					,	config_class=A__					,	has_text_modality=A__		)


						def  __A ( self			:       Optional[int]		):





												'''simple docstring'''





												self.config_tester.run_common_tests()


						def  __A ( self			:       Dict		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE							:					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			:       Optional[Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Tuple           =							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			:       Union[str, Any]		):





												'''simple docstring'''





												pass


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





												'''simple docstring'''





												pass


						@unittest.skip(reason='''Mask2Former is not a generative model'''		)
						def  __A ( self			:       Optional[Any]		):





												'''simple docstring'''





												pass


						@unittest.skip(reason='''Mask2Former does not use token embeddings'''		)
						def  __A ( self			:       Optional[int]		):





												'''simple docstring'''





												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			:       List[Any]		):





												'''simple docstring'''





												pass


						@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''		)
						def  __A ( self			:       Optional[Any]		):





												'''simple docstring'''





												pass


						def  __A ( self			:       str		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE							:					Optional[Any]           =							self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		SCREAMING_SNAKE_CASE							:					Dict           =							model_class(A__		)
																		SCREAMING_SNAKE_CASE							:					Optional[int]           =							inspect.signature(model.forward		)
																		# signature.parameters is an OrderedDict => so arg_names order is deterministic
																		SCREAMING_SNAKE_CASE							:					Optional[Any]           =							[*signature.parameters.keys()]

																		SCREAMING_SNAKE_CASE							:					Dict           =							['''pixel_values''']
																		self.assertListEqual(arg_names[:1]					,	A__		)


						@slow
						def  __A ( self			:       List[Any]		):





												'''simple docstring'''





												for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
																		SCREAMING_SNAKE_CASE							:					Optional[int]           =							MaskaFormerModel.from_pretrained(A__		)
																		self.assertIsNotNone(A__		)


						def  __A ( self			:       List[Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Dict           =							(self.model_tester.min_size,) * 2
												SCREAMING_SNAKE_CASE							:					List[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(),
												}
												SCREAMING_SNAKE_CASE							:					Any           =							self.model_tester.get_config()

												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							MaskaFormerForUniversalSegmentation(A__		).to(A__		)
												SCREAMING_SNAKE_CASE							:					str           =							model(**A__		)
												self.assertTrue(outputs.loss is not None		)


						def  __A ( self			:       Union[str, Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE							:					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[Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE							:					Optional[Any]           =							self.model_tester.prepare_config_and_inputs_for_common()

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


						def  __A ( self			:       List[str]		):





												'''simple docstring'''





												if not self.model_tester.is_training:
																		return

												SCREAMING_SNAKE_CASE							:					List[Any]           =							self.all_model_classes[1]
												SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE							:					int           =							self.model_tester.prepare_config_and_inputs()

												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							model_class(A__		)
												model.to(A__		)
												model.train()

												SCREAMING_SNAKE_CASE							:					Tuple           =							model(A__					,	mask_labels=A__					,	class_labels=A__		).loss
												loss.backward()



						def  __A ( self			:       Optional[int]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							self.all_model_classes[1]
												SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE							:					Dict           =							self.model_tester.prepare_config_and_inputs()
												SCREAMING_SNAKE_CASE							:					List[Any]           =							True
												SCREAMING_SNAKE_CASE							:					List[Any]           =							True

												SCREAMING_SNAKE_CASE							:					Optional[int]           =							model_class(A__		).to(A__		)
												model.train()

												SCREAMING_SNAKE_CASE							:					Optional[int]           =							model(A__					,	mask_labels=A__					,	class_labels=A__		)

												SCREAMING_SNAKE_CASE							:					int           =							outputs.encoder_hidden_states[0]
												encoder_hidden_states.retain_grad()

												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							outputs.pixel_decoder_hidden_states[0]
												pixel_decoder_hidden_states.retain_grad()

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

												SCREAMING_SNAKE_CASE							:					str           =							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		)






__UpperCamelCase	: Tuple    		=  1e-4
def    A			(					):
						SCREAMING_SNAKE_CASE							:					Tuple           =							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
						return image





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


						@cached_property
						def  __A ( self			:       Tuple		):





												'''simple docstring'''





												return "facebook/mask2former-swin-small-coco-instance"


						@cached_property
						def  __A ( self			:       Optional[Any]		):





												'''simple docstring'''





												return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints		) if is_vision_available() else None


						def  __A ( self			:       List[Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Any           =							MaskaFormerModel.from_pretrained(self.model_checkpoints		).to(A__		)
												SCREAMING_SNAKE_CASE							:					List[Any]           =							self.default_image_processor
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							prepare_img()
												SCREAMING_SNAKE_CASE							:					Any           =							image_processor(A__					,	return_tensors='''pt'''		).to(A__		)
												SCREAMING_SNAKE_CASE							:					Optional[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, 384, 384)		)

												with torch.no_grad():
																		SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							model(**A__		)

												SCREAMING_SNAKE_CASE							:					int           =							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__		)		)

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

												SCREAMING_SNAKE_CASE							:					List[str]           =							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]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Optional[int]           =							MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints		).to(A__		).eval()
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							self.default_image_processor
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							prepare_img()
												SCREAMING_SNAKE_CASE							:					Dict           =							image_processor(A__					,	return_tensors='''pt'''		).to(A__		)
												SCREAMING_SNAKE_CASE							:					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, 384, 384)		)

												with torch.no_grad():
																		SCREAMING_SNAKE_CASE							:					Dict           =							model(**A__		)
												# masks_queries_logits
												SCREAMING_SNAKE_CASE							:					int           =							outputs.masks_queries_logits
												self.assertEqual(
												    masks_queries_logits.shape					,	(1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)		)
												SCREAMING_SNAKE_CASE							:					Tuple           =							[
												    [-8.7839, -9.0056, -8.8121],
												    [-7.4104, -7.0313, -6.5401],
												    [-6.6105, -6.3427, -6.4675],
												]
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							torch.tensor(A__		).to(A__		)
												self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]					,	A__					,	atol=A__		)		)
												# class_queries_logits
												SCREAMING_SNAKE_CASE							:					Tuple           =							outputs.class_queries_logits
												self.assertEqual(class_queries_logits.shape					,	(1, model.config.num_queries, model.config.num_labels + 1)		)
												SCREAMING_SNAKE_CASE							:					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			:       Optional[Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints		).to(A__		).eval()
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							self.default_image_processor

												SCREAMING_SNAKE_CASE							:					List[Any]           =							image_processor(
												    [np.zeros((3, 800, 1333)		), np.zeros((3, 800, 1333)		)]					,	segmentation_maps=[np.zeros((384, 384)		).astype(np.floataa		), np.zeros((384, 384)		).astype(np.floataa		)]					,	return_tensors='''pt'''					,	)

												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							inputs['''pixel_values'''].to(A__		)
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							[el.to(A__		) for el in inputs['''mask_labels''']]
												SCREAMING_SNAKE_CASE							:					Any           =							[el.to(A__		) for el in inputs['''class_labels''']]

												with torch.no_grad():
																		SCREAMING_SNAKE_CASE							:					List[str]           =							model(**A__		)

												self.assertTrue(outputs.loss is not None		)






from __future__ import annotations

from typing import Any





class       lowercase__		(     UpperCamelCase_):
						pass






class       lowercase__		:


						def __init__( self			:       Union[str, Any]					,	UpperCamelCase__			:       Any		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Any           =							data
												SCREAMING_SNAKE_CASE							:					Node | None           =							None


						def __iter__( self			:       Any		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					List[str]           =							self
												SCREAMING_SNAKE_CASE							:					Tuple           =							[]
												while node:
																		if node in visited:
																								raise ContainsLoopError
																		visited.append(UpperCamelCase__		)
																		yield node.data
																		SCREAMING_SNAKE_CASE							:					Dict           =							node.next_node



						@property
						def  __A ( self			:       Optional[int]		):





												'''simple docstring'''





												try:
																		list(self		)
																		return False
												except ContainsLoopError:
																		return True


if __name__ == "__main__":
					__UpperCamelCase	: List[Any]    		=  Node(1)
					__UpperCamelCase	: str    		=  Node(2)
					__UpperCamelCase	: Dict    		=  Node(3)
					__UpperCamelCase	: List[Any]    		=  Node(4)
					print(root_node.has_loop)  # False
					__UpperCamelCase	: int    		=  root_node.next_node
					print(root_node.has_loop)  # True

					__UpperCamelCase	: Union[str, Any]    		=  Node(5)
					__UpperCamelCase	: Union[str, Any]    		=  Node(6)
					__UpperCamelCase	: List[Any]    		=  Node(5)
					__UpperCamelCase	: List[str]    		=  Node(6)
					print(root_node.has_loop)  # False

					__UpperCamelCase	: List[Any]    		=  Node(1)
					print(root_node.has_loop)  # False





