


"""simple docstring"""


import inspect
import unittest

from transformers import ViTHybridConfig
from transformers.testing_utils import require_accelerate, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
	import torch
	from torch import nn

	from transformers import ViTHybridForImageClassification, ViTHybridImageProcessor, ViTHybridModel
	from transformers.models.vit_hybrid.modeling_vit_hybrid import VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image



class 			lowerCamelCase__						:







						def __init__(							self   :    int			,			_lowercase   :    Dict			,			_lowercase   :    List[Any]=13			,			_lowercase   :    Any=64			,			_lowercase   :    Union[str, Any]=2			,			_lowercase   :    List[str]=3			,			_lowercase   :    Union[str, Any]=True			,			_lowercase   :    Optional[int]=True			,			_lowercase   :    Dict=32			,			_lowercase   :    List[str]=5			,			_lowercase   :    Union[str, Any]=4			,			_lowercase   :    Dict=37			,			_lowercase   :    List[str]="gelu"			,			_lowercase   :    str=0.1			,			_lowercase   :    List[str]=0.1			,			_lowercase   :    List[Any]=10			,			_lowercase   :    Tuple=0.0_2			,			_lowercase   :    int=[1, 16, 4, 4]			,			_lowercase   :    int=None			,			):
								A					       = parent
								A					       = batch_size
								A					       = image_size
								A					       = patch_size
								A					       = num_channels
								A					       = is_training
								A					       = use_labels
								A					       = hidden_size
								A					       = num_hidden_layers
								A					       = num_attention_heads
								A					       = intermediate_size
								A					       = hidden_act
								A					       = hidden_dropout_prob
								A					       = attention_probs_dropout_prob
								A					       = type_sequence_label_size
								A					       = initializer_range
								A					       = scope
								A					       = backbone_featmap_shape

								# in ViT hybrid, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
								# the number of patches is based on the feature map of the backbone, which by default uses an output stride
								# of 32, which means that the feature map has a spatial resolution of 1/32 of the input image size
								A					       = (self.image_size // 32) ** 2
								A					       = num_patches + 1







						def __a						(							self   :    Union[str, Any]		):
								A					       = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

								A					       = self.get_config()

								return config, pixel_values, labels







						def __a						(							self   :    List[str]		):
								A					       = {
								    'global_padding': 'same',
								    'layer_type': 'bottleneck',
								    'depths': [3, 4, 9],
								    'out_features': ['stage1', 'stage2', 'stage3'],
								    'embedding_dynamic_padding': True,
								    'hidden_sizes': [4, 8, 16, 32],
								    'num_groups': 2,
								}

								return ViTHybridConfig(
								    image_size=self.image_size			,			patch_size=self.patch_size			,			num_channels=self.num_channels			,			hidden_size=self.hidden_size			,			num_hidden_layers=self.num_hidden_layers			,			num_attention_heads=self.num_attention_heads			,			intermediate_size=self.intermediate_size			,			hidden_act=self.hidden_act			,			hidden_dropout_prob=self.hidden_dropout_prob			,			attention_probs_dropout_prob=self.attention_probs_dropout_prob			,			is_decoder=_lowercase			,			initializer_range=self.initializer_range			,			backbone_featmap_shape=self.backbone_featmap_shape			,			backbone_config=_lowercase			,			)







						def __a						(							self   :    Dict			,			_lowercase   :    Optional[Any]			,			_lowercase   :    Tuple			,			_lowercase   :    Dict		):
								A					       = ViTHybridModel(config=_lowercase		)
								model.to(_lowercase		)
								model.eval()
								A					       = model(_lowercase		)
								self.parent.assertEqual(result.last_hidden_state.shape			,			(self.batch_size, self.seq_length, self.hidden_size)		)







						def __a						(							self   :    Tuple			,			_lowercase   :    Tuple			,			_lowercase   :    Tuple			,			_lowercase   :    List[Any]		):
								A					       = self.type_sequence_label_size
								A					       = ViTHybridForImageClassification(_lowercase		)
								model.to(_lowercase		)
								model.eval()
								A					       = model(_lowercase			,			labels=_lowercase		)
								self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.type_sequence_label_size)		)







						def __a						(							self   :    int		):
								A					       = self.prepare_config_and_inputs()
								A       , A       , A					       = config_and_inputs
								A					       = {'pixel_values': pixel_values}
								return config, inputs_dict



@require_torch
class 			lowerCamelCase__						(   UpperCAmelCase_							,    UpperCAmelCase_							,    unittest.TestCase			):
						lowerCAmelCase       =     (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
						lowerCAmelCase       =     (
						    {"""feature-extraction""": ViTHybridModel, """image-classification""": ViTHybridForImageClassification}
						    if is_torch_available()
						    else {}
						)
						lowerCAmelCase       =     False
						lowerCAmelCase       =     False
						lowerCAmelCase       =     False







						def __a						(							self   :    Optional[Any]		):
								A					       = ViTHybridModelTester(self		)
								A					       = ConfigTester(self			,			config_class=_lowercase			,			has_text_modality=_lowercase			,			hidden_size=37		)







						def __a						(							self   :    Union[str, Any]		):
								self.config_tester.run_common_tests()







						@unittest.skip(reason='ViT does not use inputs_embeds'		)
						def __a						(							self   :    Tuple		):
								pass







						def __a						(							self   :    List[str]		):
								A       , A					       = self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										A					       = model_class(_lowercase		)
										self.assertIsInstance(model.get_input_embeddings()			,			(nn.Module)		)
										A					       = model.get_output_embeddings()
										self.assertTrue(x is None or isinstance(_lowercase			,			nn.Linear		)		)







						def __a						(							self   :    int		):
								A       , A					       = self.model_tester.prepare_config_and_inputs_for_common()

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

										A					       = ['pixel_values']
										self.assertListEqual(arg_names[:1]			,			_lowercase		)







						def __a						(							self   :    List[Any]		):
								A					       = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowercase		)







						def __a						(							self   :    int		):
								A					       = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_lowercase		)







						def __a						(							self   :    Optional[int]		):
								A       , A					       = self.model_tester.prepare_config_and_inputs_for_common()

								A					       = _config_zero_init(_lowercase		)
								for model_class in self.all_model_classes:
										A					       = model_class(config=_lowercase		)
										# Skip the check for the backbone
										for name, module in model.named_modules():
												if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
														A					       = [f'{name}.{key}' for key in module.state_dict().keys()]
														break

										for name, param in model.named_parameters():
												if param.requires_grad:
														if name in backbone_params:
																continue
														self.assertIn(
														    ((param.data.mean() * 1e9).round() / 1e9).item()			,			[0.0, 1.0]			,			msg=f'Parameter {name} of model {model_class} seems not properly initialized'			,			)







						@slow
						def __a						(							self   :    List[Any]		):
								for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										A					       = ViTHybridModel.from_pretrained(_lowercase		)
										self.assertIsNotNone(_lowercase		)







def  __snake_case       (   )      ->		int:







		"""simple docstring"""





		A					       = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
		return image



@require_torch
@require_vision
class 			lowerCamelCase__						(   unittest.TestCase			):







						@cached_property
						def __a						(							self   :    int		):
								return (
								    ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)
								    if is_vision_available()
								    else None
								)







						@slow
						def __a						(							self   :    Optional[int]		):
								A					       = ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(
								    _lowercase		)

								A					       = self.default_image_processor
								A					       = prepare_img()
								A					       = image_processor(images=_lowercase			,			return_tensors='pt'		).to(_lowercase		)

								# forward pass
								with torch.no_grad():
										A					       = model(**_lowercase		)

								# verify the logits
								A					       = torch.Size((1, 1_000)		)
								self.assertEqual(outputs.logits.shape			,			_lowercase		)

								A					       = torch.tensor([-1.9_0_9_0, -0.4_9_9_3, -0.2_3_8_9]		).to(_lowercase		)

								self.assertTrue(torch.allclose(outputs.logits[0, :3]			,			_lowercase			,			atol=1e-4		)		)







						@slow
						@require_accelerate
						def __a						(							self   :    str		):
								A					       = ViTHybridImageProcessor.from_pretrained('google/vit-hybrid-base-bit-384'		)
								A					       = ViTHybridForImageClassification.from_pretrained('google/vit-hybrid-base-bit-384'			,			device_map='auto'		)

								A					       = prepare_img()

								A					       = image_processor(images=_lowercase			,			return_tensors='pt'		)
								A					       = model(**_lowercase		)
								A					       = outputs.logits
								# model predicts one of the 1000 ImageNet classes
								A					       = logits.argmax(-1		).item()

								self.assertTrue(model.config.idalabel[predicted_class_idx]			,			'tabby, tabby cat'		)









"""simple docstring"""


from datetime import datetime as dt
import os

from github import Github


UpperCamelCase						:				Union[str, Any]             =      [
    "good first issue",
    "good second issue",
    "good difficult issue",
    "feature request",
    "new model",
    "wip",
]







def  __snake_case       (   )      ->		int:







		"""simple docstring"""





		A					       = Github(os.environ['GITHUB_TOKEN']	)
		A					       = g.get_repo('huggingface/transformers'	)
		A					       = repo.get_issues(state='open'	)

		for issue in open_issues:
				A					       = sorted([comment for comment in issue.get_comments()] ,			key=lambda UpperCamelCase__	: i.created_at ,			reverse=UpperCamelCase__	)
				A					       = comments[0] if len(UpperCamelCase__	) > 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()	)
				):
						# print(f"Would close issue {issue.number} since it has been 7 days of inactivity since bot mention.")
						issue.edit(state='closed'	)
				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()	)
				):
						# print(f"Would add stale comment to {issue.number}")
						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/transformers/blob/main/CONTRIBUTING.md) '
						    'are likely to be ignored.'	)


if __name__ == "__main__":
	main()





