



'''simple docstring'''

import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch
	from torch import nn

	from transformers import MaskFormerSwinBackbone
	from transformers.models.maskformer import MaskFormerSwinModel


class 	a__     :


	def __init__(self : List[str],					__UpperCAmelCase : Dict,					__UpperCAmelCase : Any=13,					__UpperCAmelCase : List[Any]=32,					__UpperCAmelCase : int=2,					__UpperCAmelCase : Optional[int]=3,					__UpperCAmelCase : Tuple=16,					__UpperCAmelCase : Optional[Any]=[1, 2, 1],					__UpperCAmelCase : str=[2, 2, 4],					__UpperCAmelCase : Optional[Any]=2,					__UpperCAmelCase : List[str]=2.0,					__UpperCAmelCase : Tuple=True,					__UpperCAmelCase : Dict=0.0,					__UpperCAmelCase : List[Any]=0.0,					__UpperCAmelCase : Union[str, Any]=0.1,					__UpperCAmelCase : Optional[int]="gelu",					__UpperCAmelCase : Tuple=False,					__UpperCAmelCase : Tuple=True,					__UpperCAmelCase : List[Any]=0.02,					__UpperCAmelCase : Optional[int]=1e-5,					__UpperCAmelCase : int=True,					__UpperCAmelCase : Dict=None,					__UpperCAmelCase : Any=True,					__UpperCAmelCase : Optional[int]=10,					__UpperCAmelCase : str=8,					__UpperCAmelCase : str=["stage1", "stage2", "stage3"],					__UpperCAmelCase : int=[1, 2, 3],					)     ->			List[str]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						List[Any]      					= parent
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= batch_size
					SCREAMING_SNAKE_CASE  :						List[str]      					= image_size
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= patch_size
					SCREAMING_SNAKE_CASE  :						Any      					= num_channels
					SCREAMING_SNAKE_CASE  :						Any      					= embed_dim
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= depths
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= num_heads
					SCREAMING_SNAKE_CASE  :						Dict      					= window_size
					SCREAMING_SNAKE_CASE  :						Any      					= mlp_ratio
					SCREAMING_SNAKE_CASE  :						int      					= qkv_bias
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= hidden_dropout_prob
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= attention_probs_dropout_prob
					SCREAMING_SNAKE_CASE  :						int      					= drop_path_rate
					SCREAMING_SNAKE_CASE  :						List[str]      					= hidden_act
					SCREAMING_SNAKE_CASE  :						Any      					= use_absolute_embeddings
					SCREAMING_SNAKE_CASE  :						Any      					= patch_norm
					SCREAMING_SNAKE_CASE  :						int      					= layer_norm_eps
					SCREAMING_SNAKE_CASE  :						Tuple      					= initializer_range
					SCREAMING_SNAKE_CASE  :						int      					= is_training
					SCREAMING_SNAKE_CASE  :						Dict      					= scope
					SCREAMING_SNAKE_CASE  :						Tuple      					= use_labels
					SCREAMING_SNAKE_CASE  :						List[Any]      					= type_sequence_label_size
					SCREAMING_SNAKE_CASE  :						Tuple      					= encoder_stride
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= out_features
					SCREAMING_SNAKE_CASE  :						int      					= out_indices


	def 				lowercase__  (self : Any      )     ->			Optional[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						Any      					= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

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

					return config, pixel_values, labels


	def 				lowercase__  (self : Tuple      )     ->			List[Any]:

					"""simple docstring"""

					return MaskFormerSwinConfig(
					    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,					out_features=self.out_features,					out_indices=self.out_indices,					)


	def 				lowercase__  (self : int,					__UpperCAmelCase : Tuple,					__UpperCAmelCase : List[str],					__UpperCAmelCase : List[Any]      )     ->			Any:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						int      					= MaskFormerSwinModel(config=__UpperCAmelCase      )
					model.to(__UpperCAmelCase      )
					model.eval()
					SCREAMING_SNAKE_CASE  :						int      					= model(__UpperCAmelCase      )

					SCREAMING_SNAKE_CASE  :						Dict      					= ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths      ) - 1))
					SCREAMING_SNAKE_CASE  :						str      					= 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 				lowercase__  (self : Optional[Any],					__UpperCAmelCase : Dict,					__UpperCAmelCase : List[Any],					__UpperCAmelCase : Optional[Any]      )     ->			int:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						Any      					= MaskFormerSwinBackbone(config=__UpperCAmelCase      )
					model.to(__UpperCAmelCase      )
					model.eval()
					SCREAMING_SNAKE_CASE  :						List[str]      					= model(__UpperCAmelCase      )

					# verify feature maps
					self.parent.assertEqual(len(result.feature_maps      ),					len(config.out_features      )      )
					self.parent.assertListEqual(list(result.feature_maps[0].shape      ),					[13, 16, 16, 16]      )

					# verify channels
					self.parent.assertEqual(len(model.channels      ),					len(config.out_features      )      )
					self.parent.assertListEqual(model.channels,					[16, 32, 64]      )

					# verify ValueError
					with self.parent.assertRaises(__UpperCAmelCase      ):
									SCREAMING_SNAKE_CASE  :						Optional[int]      					= ['''stem''']
									SCREAMING_SNAKE_CASE  :						int      					= MaskFormerSwinBackbone(config=__UpperCAmelCase      )






	def 				lowercase__  (self : int      )     ->			Optional[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						List[Any]      					= self.prepare_config_and_inputs()
					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE  :						int      					= config_and_inputs
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= {'''pixel_values''': pixel_values}
					return config, inputs_dict



@require_torch
class 	a__     (				_lowercase,			_lowercase,			unittest.TestCase	):
	__magic_name__		:    Optional[int]	    =     (
	    (
	        MaskFormerSwinModel,
	        MaskFormerSwinBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	__magic_name__		:    List[str]	    =     {"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
	__magic_name__		:    Tuple	    =     False
	__magic_name__		:    Optional[Any]	    =     False
	__magic_name__		:    Optional[int]	    =     False
	__magic_name__		:    Tuple	    =     False
	__magic_name__		:    int	    =     False


	def 				lowercase__  (self : Union[str, Any]      )     ->			List[str]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						List[str]      					= MaskFormerSwinModelTester(self      )
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= ConfigTester(self,					config_class=__UpperCAmelCase,					embed_dim=37      )


	@require_torch_multi_gpu
	@unittest.skip(
	    reason=(
	        '''`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'''
	        ''' `nn.DataParallel`'''
	    )      )
	def 				lowercase__  (self : Any      )     ->			Tuple:

					"""simple docstring"""

					pass


	def 				lowercase__  (self : Optional[int]      )     ->			Any:

					"""simple docstring"""

					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 				lowercase__  (self : List[str]      )     ->			List[str]:

					"""simple docstring"""

					return


	def 				lowercase__  (self : List[Any]      )     ->			Optional[int]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*__UpperCAmelCase      )


	def 				lowercase__  (self : str      )     ->			Union[str, Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*__UpperCAmelCase      )


	@unittest.skip('''Swin does not use inputs_embeds'''      )
	def 				lowercase__  (self : Optional[Any]      )     ->			List[Any]:

					"""simple docstring"""

					pass


	@unittest.skip('''Swin does not support feedforward chunking'''      )
	def 				lowercase__  (self : Union[str, Any]      )     ->			int:

					"""simple docstring"""

					pass


	def 				lowercase__  (self : int      )     ->			Any:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE  :						int      					= self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE  :						str      					= model_class(__UpperCAmelCase      )
									self.assertIsInstance(model.get_input_embeddings(),					(nn.Module)      )
									SCREAMING_SNAKE_CASE  :						List[str]      					= model.get_output_embeddings()
									self.assertTrue(x is None or isinstance(__UpperCAmelCase,					nn.Linear      )      )


	def 				lowercase__  (self : Tuple      )     ->			List[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE  :						Tuple      					= self.model_tester.prepare_config_and_inputs_for_common()

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

									SCREAMING_SNAKE_CASE  :						int      					= ['''pixel_values''']
									self.assertListEqual(arg_names[:1],					__UpperCAmelCase      )


	@unittest.skip(reason='''MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'''      )
	def 				lowercase__  (self : Optional[int]      )     ->			List[Any]:

					"""simple docstring"""

					pass


	@unittest.skip(reason='''MaskFormerSwin is only used as an internal backbone'''      )
	def 				lowercase__  (self : Dict      )     ->			Dict:

					"""simple docstring"""

					pass


	def 				lowercase__  (self : int,					__UpperCAmelCase : Any,					__UpperCAmelCase : List[str],					__UpperCAmelCase : Optional[Any],					__UpperCAmelCase : Optional[Any]      )     ->			Optional[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= model_class(__UpperCAmelCase      )
					model.to(__UpperCAmelCase      )
					model.eval()

					with torch.no_grad():
									SCREAMING_SNAKE_CASE  :						str      					= model(**self._prepare_for_class(__UpperCAmelCase,					__UpperCAmelCase      )      )

					SCREAMING_SNAKE_CASE  :						str      					= outputs.hidden_states

					SCREAMING_SNAKE_CASE  :						Optional[int]      					= 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
					SCREAMING_SNAKE_CASE  :						List[Any]      					= (
					    config.patch_size
					    if isinstance(config.patch_size,					collections.abc.Iterable      )
					    else (config.patch_size, config.patch_size)
					)

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


	def 				lowercase__  (self : List[Any]      )     ->			Optional[Any]:

					"""simple docstring"""

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

					SCREAMING_SNAKE_CASE  :						List[Any]      					= (
					    self.model_tester.image_size
					    if isinstance(self.model_tester.image_size,					collections.abc.Iterable      )
					    else (self.model_tester.image_size, self.model_tester.image_size)
					)

					for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE  :						Optional[int]      					= 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"]
									SCREAMING_SNAKE_CASE  :						List[Any]      					= True

									self.check_hidden_states_output(__UpperCAmelCase,					__UpperCAmelCase,					__UpperCAmelCase,					__UpperCAmelCase      )


	def 				lowercase__  (self : Dict      )     ->			List[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE  :						List[Any]      					= self.model_tester.prepare_config_and_inputs_for_common()
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= 3

					SCREAMING_SNAKE_CASE  :						str      					= (
					    self.model_tester.image_size
					    if isinstance(self.model_tester.image_size,					collections.abc.Iterable      )
					    else (self.model_tester.image_size, self.model_tester.image_size)
					)
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= (
					    config.patch_size
					    if isinstance(config.patch_size,					collections.abc.Iterable      )
					    else (config.patch_size, config.patch_size)
					)

					SCREAMING_SNAKE_CASE  :						List[Any]      					= image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

					for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE  :						List[str]      					= 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"]
									SCREAMING_SNAKE_CASE  :						Any      					= True
									self.check_hidden_states_output(__UpperCAmelCase,					__UpperCAmelCase,					__UpperCAmelCase,					(padded_height, padded_width)      )


	@unittest.skip(reason='''MaskFormerSwin doesn\'t have pretrained checkpoints'''      )
	def 				lowercase__  (self : Optional[int]      )     ->			str:

					"""simple docstring"""

					pass


	@unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin'''      )
	def 				lowercase__  (self : Union[str, Any]      )     ->			List[str]:

					"""simple docstring"""

					pass


	@unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin'''      )
	def 				lowercase__  (self : int      )     ->			Optional[Any]:

					"""simple docstring"""

					pass






	def 				lowercase__  (self : Union[str, Any]      )     ->			Dict:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE  :						List[str]      					= self.model_tester.prepare_config_and_inputs_for_common()

					def set_nan_tensor_to_zero(__UpperCAmelCase : Tuple      ):
									SCREAMING_SNAKE_CASE  :						Optional[int]      					= 0
									return t

					def check_equivalence(__UpperCAmelCase : Any,					__UpperCAmelCase : Optional[int],					__UpperCAmelCase : List[str],					__UpperCAmelCase : str={}      ):
									with torch.no_grad():
													SCREAMING_SNAKE_CASE  :						Any      					= model(**__UpperCAmelCase,					return_dict=__UpperCAmelCase,					**__UpperCAmelCase      )
													SCREAMING_SNAKE_CASE  :						Any      					= model(**__UpperCAmelCase,					return_dict=__UpperCAmelCase,					**__UpperCAmelCase      ).to_tuple()

													def recursive_check(__UpperCAmelCase : str,					__UpperCAmelCase : List[str]      ):
																	if isinstance(__UpperCAmelCase,					(List, Tuple)      ):
																					for tuple_iterable_value, dict_iterable_value in zip(__UpperCAmelCase,					__UpperCAmelCase      ):
																									recursive_check(__UpperCAmelCase,					__UpperCAmelCase      )
																	elif isinstance(__UpperCAmelCase,					__UpperCAmelCase      ):
																					for tuple_iterable_value, dict_iterable_value in zip(
																					    tuple_object.values(),					dict_object.values()      ):
																									recursive_check(__UpperCAmelCase,					__UpperCAmelCase      )
																	elif tuple_object is None:
																					return
																	else:
																					self.assertTrue(
																					    torch.allclose(
																					        set_nan_tensor_to_zero(__UpperCAmelCase      ),					set_nan_tensor_to_zero(__UpperCAmelCase      ),					atol=1e-5      ),					msg=(
																					        '''Tuple and dict output are not equal. Difference:'''
																					        F''' {torch.max(torch.abs(tuple_object - dict_object      )      )}. Tuple has `nan`:'''
																					        F''' {torch.isnan(__UpperCAmelCase      ).any()} and `inf`: {torch.isinf(__UpperCAmelCase      )}. Dict has'''
																					        F''' `nan`: {torch.isnan(__UpperCAmelCase      ).any()} and `inf`: {torch.isinf(__UpperCAmelCase      )}.'''
																					    ),					)

													recursive_check(__UpperCAmelCase,					__UpperCAmelCase      )

					for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE  :						int      					= model_class(__UpperCAmelCase      )
									model.to(__UpperCAmelCase      )
									model.eval()

									SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= self._prepare_for_class(__UpperCAmelCase,					__UpperCAmelCase      )
									SCREAMING_SNAKE_CASE  :						Dict      					= self._prepare_for_class(__UpperCAmelCase,					__UpperCAmelCase      )
									check_equivalence(__UpperCAmelCase,					__UpperCAmelCase,					__UpperCAmelCase      )

									SCREAMING_SNAKE_CASE  :						Dict      					= self._prepare_for_class(__UpperCAmelCase,					__UpperCAmelCase,					return_labels=__UpperCAmelCase      )
									SCREAMING_SNAKE_CASE  :						Dict      					= self._prepare_for_class(__UpperCAmelCase,					__UpperCAmelCase,					return_labels=__UpperCAmelCase      )
									check_equivalence(__UpperCAmelCase,					__UpperCAmelCase,					__UpperCAmelCase      )

									SCREAMING_SNAKE_CASE  :						Optional[int]      					= self._prepare_for_class(__UpperCAmelCase,					__UpperCAmelCase      )
									SCREAMING_SNAKE_CASE  :						Tuple      					= self._prepare_for_class(__UpperCAmelCase,					__UpperCAmelCase      )
									check_equivalence(__UpperCAmelCase,					__UpperCAmelCase,					__UpperCAmelCase,					{'''output_hidden_states''': True}      )

									SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= self._prepare_for_class(__UpperCAmelCase,					__UpperCAmelCase,					return_labels=__UpperCAmelCase      )
									SCREAMING_SNAKE_CASE  :						Optional[int]      					= self._prepare_for_class(__UpperCAmelCase,					__UpperCAmelCase,					return_labels=__UpperCAmelCase      )
									check_equivalence(__UpperCAmelCase,					__UpperCAmelCase,					__UpperCAmelCase,					{'''output_hidden_states''': True}      )



@require_torch
class 	a__     (				unittest.TestCase,			_lowercase	):
	__magic_name__		:    Tuple	    =     (MaskFormerSwinBackbone,) if is_torch_available() else ()
	__magic_name__		:    List[Any]	    =     MaskFormerSwinConfig


	def 				lowercase__  (self : Optional[Any]      )     ->			List[str]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						Any      					= MaskFormerSwinModelTester(self      )






	def 				lowercase__  (self : Union[str, Any]      )     ->			Tuple:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE  :						List[Any]      					= self.model_tester.prepare_config_and_inputs_for_common()
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= inputs_dict['''pixel_values'''].shape[0]

					for backbone_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= backbone_class(__UpperCAmelCase      )
									backbone.to(__UpperCAmelCase      )
									backbone.eval()

									SCREAMING_SNAKE_CASE  :						Optional[int]      					= backbone(**__UpperCAmelCase      )

									# Test default outputs and verify feature maps
									self.assertIsInstance(outputs.feature_maps,					__UpperCAmelCase      )
									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
									SCREAMING_SNAKE_CASE  :						Tuple      					= backbone(**__UpperCAmelCase,					output_hidden_states=__UpperCAmelCase      )
									self.assertIsNotNone(outputs.hidden_states      )
									self.assertTrue(len(outputs.hidden_states      ),					len(backbone.stage_names      )      )
									# We skip the stem layer
									for hidden_states, n_channels in zip(outputs.hidden_states[1:],					backbone.channels      ):
													for hidden_state in hidden_states:
																	# Hidden states are in the format (batch_size, (height * width), n_channels)
																	SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE  :						Optional[int]      					= hidden_state.shape
																	self.assertTrue((h_batch_size, h_n_channels),					(batch_size, n_channels)      )

            # Test output_attentions=True
									if self.has_attentions:
													SCREAMING_SNAKE_CASE  :						List[str]      					= backbone(**__UpperCAmelCase,					output_attentions=__UpperCAmelCase      )
													self.assertIsNotNone(outputs.attentions      )









'''simple docstring'''

import os
from datetime import datetime as dt

from github import Github


snake_case_			=     [
    """good first issue""",
    """good second issue""",
    """good difficult issue""",
    """enhancement""",
    """new pipeline/model""",
    """new scheduler""",
    """wip""",
]






def       __lowercase  ():
				SCREAMING_SNAKE_CASE  :						List[Any]      					= Github(os.environ['''GITHUB_TOKEN''']       )
				SCREAMING_SNAKE_CASE  :						List[str]      					= g.get_repo('''huggingface/diffusers'''       )
				SCREAMING_SNAKE_CASE  :						List[str]      					= repo.get_issues(state='''open'''       )

				for issue in open_issues:
								SCREAMING_SNAKE_CASE  :						List[Any]      					= sorted(issue.get_comments()    ,	key=lambda _SCREAMING_SNAKE_CASE       : i.created_at    ,	reverse=_SCREAMING_SNAKE_CASE       )
								SCREAMING_SNAKE_CASE  :						Optional[int]      					= comments[0] if len(_SCREAMING_SNAKE_CASE       ) > 0 else None
								if (
								    last_comment is not None
								    and last_comment.user.login == "github-actions[bot]"
								    and (dt.utcnow() - issue.updated_at).days > 7
								    and (dt.utcnow() - issue.created_at).days >= 30
								    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()       )
								):
												# Closes the issue after 7 days of inactivity since the Stalebot notification.
												issue.edit(state='''closed'''       )
								elif (
								    "stale" in issue.get_labels()
								    and last_comment is not None
								    and last_comment.user.login != "github-actions[bot]"
								):
												# Opens the issue if someone other than Stalebot commented.
												issue.edit(state='''open'''       )
												issue.remove_from_labels('''stale'''       )
								elif (
								    (dt.utcnow() - issue.updated_at).days > 23
								    and (dt.utcnow() - issue.created_at).days >= 30
								    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()       )
								):
												# Post a Stalebot notification after 23 days of inactivity.
												issue.create_comment(
												    '''This issue has been automatically marked as stale because it has not had '''
												    '''recent activity. If you think this still needs to be addressed '''
												    '''please comment on this thread.\n\nPlease note that issues that do not follow the '''
												    '''[contributing guidelines](https://github.com/huggingface/diffusers/blob/main/CONTRIBUTING.md) '''
												    '''are likely to be ignored.'''       )
												issue.add_to_labels('''stale'''       )


if __name__ == "__main__":
	main()




