



'''simple docstring'''




import inspect
import unittest

from transformers import MobileViTVaConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, 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, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
							from transformers.models.mobilevitva.modeling_mobilevitva import (
							    MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
							    make_divisible,
							)


if is_vision_available():
							from PIL import Image

							from transformers import MobileViTImageProcessor

class     UpperCamelCase_				(							__UpperCAmelCase    ):





	def 				_lowercase(						self					)    ->    str:
								UpperCAmelCase  :	int							  =	self.config_class(**self.inputs_dict					)
								self.parent.assertTrue(hasattr(_lowerCamelCase	,	"""width_multiplier"""					)					)




class     UpperCamelCase_				:





	def __init__(						self	,	A	,	A=13	,	A=64	,	A=2	,	A=3	,	A="swish"	,	A=3	,	A=32	,	A=0.1	,	A=0.0_2	,	A=True	,	A=True	,	A=10	,	A=None	,	A=0.2_5	,	A=0.0	,	A=0.0	,	)    ->    str:
								UpperCAmelCase  :	Tuple							  =	parent
								UpperCAmelCase  :	Optional[Any]							  =	batch_size
								UpperCAmelCase  :	List[str]							  =	image_size
								UpperCAmelCase  :	Any							  =	patch_size
								UpperCAmelCase  :	int							  =	num_channels
								UpperCAmelCase  :	Optional[Any]							  =	make_divisible(512 * width_multiplier	,	divisor=8					)
								UpperCAmelCase  :	Tuple							  =	hidden_act
								UpperCAmelCase  :	Dict							  =	conv_kernel_size
								UpperCAmelCase  :	List[str]							  =	output_stride
								UpperCAmelCase  :	List[Any]							  =	classifier_dropout_prob
								UpperCAmelCase  :	Any							  =	use_labels
								UpperCAmelCase  :	Optional[Any]							  =	is_training
								UpperCAmelCase  :	Dict							  =	num_labels
								UpperCAmelCase  :	Dict							  =	initializer_range
								UpperCAmelCase  :	Optional[Any]							  =	scope
								UpperCAmelCase  :	Optional[Any]							  =	width_multiplier
								UpperCAmelCase  :	Union[str, Any]							  =	ffn_dropout
								UpperCAmelCase  :	int							  =	attn_dropout





	def 				_lowercase(						self					)    ->    int:
								UpperCAmelCase  :	Tuple							  =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

								UpperCAmelCase  :	Optional[Any]							  =	None
								UpperCAmelCase  :	Tuple							  =	None
								if self.use_labels:
															UpperCAmelCase  :	List[Any]							  =	ids_tensor([self.batch_size]	,	self.num_labels					)
															UpperCAmelCase  :	Optional[Any]							  =	ids_tensor([self.batch_size, self.image_size, self.image_size]	,	self.num_labels					)

								UpperCAmelCase  :	Optional[int]							  =	self.get_config()

								return config, pixel_values, labels, pixel_labels





	def 				_lowercase(						self					)    ->    List[Any]:
								return MobileViTVaConfig(
								    image_size=self.image_size	,	patch_size=self.patch_size	,	num_channels=self.num_channels	,	hidden_act=self.hidden_act	,	conv_kernel_size=self.conv_kernel_size	,	output_stride=self.output_stride	,	classifier_dropout_prob=self.classifier_dropout_prob	,	initializer_range=self.initializer_range	,	width_multiplier=self.width_multiplier	,	ffn_dropout=self.ffn_dropout_prob	,	attn_dropout=self.attn_dropout_prob	,	)





	def 				_lowercase(						self	,	A	,	A	,	A	,	A					)    ->    Union[str, Any]:
								UpperCAmelCase  :	int							  =	MobileViTVaModel(config=_lowerCamelCase					)
								model.to(_lowerCamelCase					)
								model.eval()
								UpperCAmelCase  :	Tuple							  =	model(_lowerCamelCase					)
								self.parent.assertEqual(
								    result.last_hidden_state.shape	,	(
								        self.batch_size,
								        self.last_hidden_size,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    )	,	)





	def 				_lowercase(						self	,	A	,	A	,	A	,	A					)    ->    Optional[Any]:
								UpperCAmelCase  :	Any							  =	self.num_labels
								UpperCAmelCase  :	List[Any]							  =	MobileViTVaForImageClassification(_lowerCamelCase					)
								model.to(_lowerCamelCase					)
								model.eval()
								UpperCAmelCase  :	Optional[int]							  =	model(_lowerCamelCase	,	labels=_lowerCamelCase					)
								self.parent.assertEqual(result.logits.shape	,	(self.batch_size, self.num_labels)					)





	def 				_lowercase(						self	,	A	,	A	,	A	,	A					)    ->    Dict:
								UpperCAmelCase  :	Optional[int]							  =	self.num_labels
								UpperCAmelCase  :	Dict							  =	MobileViTVaForSemanticSegmentation(_lowerCamelCase					)
								model.to(_lowerCamelCase					)
								model.eval()
								UpperCAmelCase  :	List[str]							  =	model(_lowerCamelCase					)
								self.parent.assertEqual(
								    result.logits.shape	,	(
								        self.batch_size,
								        self.num_labels,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    )	,	)
								UpperCAmelCase  :	List[Any]							  =	model(_lowerCamelCase	,	labels=_lowerCamelCase					)
								self.parent.assertEqual(
								    result.logits.shape	,	(
								        self.batch_size,
								        self.num_labels,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    )	,	)






	def 				_lowercase(						self					)    ->    str:
								UpperCAmelCase  :	List[str]							  =	self.prepare_config_and_inputs()
								UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  :	Optional[Any]							  =	config_and_inputs
								UpperCAmelCase  :	Dict							  =	{"""pixel_values""": pixel_values}
								return config, inputs_dict




@require_torch
class     UpperCamelCase_				(							__UpperCAmelCase   ,  __UpperCAmelCase   ,  unittest.TestCase    ):
	lowercase    =				(
	    (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
	    if is_torch_available()
	    else ()
	)

	lowercase    =				(
	    {
	        "feature-extraction": MobileViTVaModel,
	        "image-classification": MobileViTVaForImageClassification,
	        "image-segmentation": MobileViTVaForSemanticSegmentation,
	    }
	    if is_torch_available()
	    else {}
	)

	lowercase    =				False
	lowercase    =				False
	lowercase    =				False
	lowercase    =				False





	def 				_lowercase(						self					)    ->    Any:
								UpperCAmelCase  :	Tuple							  =	MobileViTVaModelTester(self					)
								UpperCAmelCase  :	Any							  =	MobileViTVaConfigTester(self	,	config_class=_lowerCamelCase	,	has_text_modality=_lowerCamelCase					)





	def 				_lowercase(						self					)    ->    List[Any]:
								self.config_tester.run_common_tests()





	@unittest.skip(reason="""MobileViTV2 does not use inputs_embeds"""					)
	def 				_lowercase(						self					)    ->    List[Any]:
								pass





	@unittest.skip(reason="""MobileViTV2 does not support input and output embeddings"""					)
	def 				_lowercase(						self					)    ->    Optional[Any]:
								pass





	@unittest.skip(reason="""MobileViTV2 does not output attentions"""					)
	def 				_lowercase(						self					)    ->    Optional[int]:
								pass





	@require_torch_multi_gpu
	@unittest.skip(reason="""Got `CUDA error: misaligned address` for tests after this one being run."""					)
	def 				_lowercase(						self					)    ->    List[str]:
								pass





	@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""					)
	def 				_lowercase(						self					)    ->    Optional[Any]:
								pass





	def 				_lowercase(						self					)    ->    Union[str, Any]:
								UpperCAmelCase  ,  UpperCAmelCase  :	Tuple							  =	self.model_tester.prepare_config_and_inputs_for_common()

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

															UpperCAmelCase  :	Optional[Any]							  =	["""pixel_values"""]
															self.assertListEqual(arg_names[:1]	,	_lowerCamelCase					)





	def 				_lowercase(						self					)    ->    List[Any]:
								UpperCAmelCase  :	Dict							  =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowerCamelCase					)





	def 				_lowercase(						self					)    ->    List[Any]:
								def check_hidden_states_output(A	,	A	,	A					):
															UpperCAmelCase  :	Optional[int]							  =	model_class(_lowerCamelCase					)
															model.to(_lowerCamelCase					)
															model.eval()

															with torch.no_grad():
																						UpperCAmelCase  :	Tuple							  =	model(**self._prepare_for_class(_lowerCamelCase	,	_lowerCamelCase					)					)

															UpperCAmelCase  :	Optional[Any]							  =	outputs.hidden_states

															UpperCAmelCase  :	int							  =	5
															self.assertEqual(len(_lowerCamelCase					)	,	_lowerCamelCase					)

															# MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
															# with the width and height being successively divided by 2.
															UpperCAmelCase  :	Tuple							  =	2
															for i in range(len(_lowerCamelCase					)					):
																						self.assertListEqual(
																						    list(hidden_states[i].shape[-2:]					)	,	[self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]	,	)
																						divisor *= 2

															self.assertEqual(self.model_tester.output_stride	,	divisor // 2					)

								UpperCAmelCase  ,  UpperCAmelCase  :	Union[str, Any]							  =	self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
															UpperCAmelCase  :	str							  =	True
															check_hidden_states_output(_lowerCamelCase	,	_lowerCamelCase	,	_lowerCamelCase					)

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															UpperCAmelCase  :	Union[str, Any]							  =	True

															check_hidden_states_output(_lowerCamelCase	,	_lowerCamelCase	,	_lowerCamelCase					)





	def 				_lowercase(						self					)    ->    Union[str, Any]:
								UpperCAmelCase  :	Optional[Any]							  =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase					)





	def 				_lowercase(						self					)    ->    Optional[Any]:
								UpperCAmelCase  :	List[Any]							  =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_semantic_segmentation(*_lowerCamelCase					)






	@slow
	def 				_lowercase(						self					)    ->    str:
								for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															UpperCAmelCase  :	List[Any]							  =	MobileViTVaModel.from_pretrained(_lowerCamelCase					)
															self.assertIsNotNone(_lowerCamelCase					)




def    __lowerCamelCase						(      )   ->    Optional[Any]:
							UpperCAmelCase  :	Dict							  =	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""	)
							return image


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





	@cached_property
	def 				_lowercase(						self					)    ->    int:
								return (
								    MobileViTImageProcessor.from_pretrained("""apple/mobilevitv2-1.0-imagenet1k-256"""					)
								    if is_vision_available()
								    else None
								)





	@slow
	def 				_lowercase(						self					)    ->    Dict:
								UpperCAmelCase  :	Any							  =	MobileViTVaForImageClassification.from_pretrained("""apple/mobilevitv2-1.0-imagenet1k-256"""					).to(
								    _lowerCamelCase					)

								UpperCAmelCase  :	Optional[int]							  =	self.default_image_processor
								UpperCAmelCase  :	Dict							  =	prepare_img()
								UpperCAmelCase  :	Dict							  =	image_processor(images=_lowerCamelCase	,	return_tensors="""pt"""					).to(_lowerCamelCase					)

								# forward pass
								with torch.no_grad():
															UpperCAmelCase  :	Optional[Any]							  =	model(**_lowerCamelCase					)

								# verify the logits
								UpperCAmelCase  :	List[str]							  =	torch.Size((1, 1000)					)
								self.assertEqual(outputs.logits.shape	,	_lowerCamelCase					)

								UpperCAmelCase  :	Optional[int]							  =	torch.tensor([-1.6_336e00, -7.3_204e-02, -5.1_883e-01]					).to(_lowerCamelCase					)

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





	@slow
	def 				_lowercase(						self					)    ->    Optional[int]:
								UpperCAmelCase  :	int							  =	MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""					)
								UpperCAmelCase  :	Tuple							  =	model.to(_lowerCamelCase					)

								UpperCAmelCase  :	List[Any]							  =	MobileViTImageProcessor.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""					)

								UpperCAmelCase  :	str							  =	prepare_img()
								UpperCAmelCase  :	str							  =	image_processor(images=_lowerCamelCase	,	return_tensors="""pt"""					).to(_lowerCamelCase					)

								# forward pass
								with torch.no_grad():
															UpperCAmelCase  :	int							  =	model(**_lowerCamelCase					)
								UpperCAmelCase  :	Optional[Any]							  =	outputs.logits

								# verify the logits
								UpperCAmelCase  :	Dict							  =	torch.Size((1, 21, 32, 32)					)
								self.assertEqual(logits.shape	,	_lowerCamelCase					)

								UpperCAmelCase  :	int							  =	torch.tensor(
								    [
								        [[7.0_8_6_3, 7.1_5_2_5, 6.8_2_0_1], [6.6_9_3_1, 6.8_7_7_0, 6.8_9_3_3], [6.2_9_7_8, 7.0_3_6_6, 6.9_6_3_6]],
								        [[-3.7_1_3_4, -3.6_7_1_2, -3.6_6_7_5], [-3.5_8_2_5, -3.3_5_4_9, -3.4_7_7_7], [-3.3_4_3_5, -3.3_9_7_9, -3.2_8_5_7]],
								        [[-2.9_3_2_9, -2.8_0_0_3, -2.7_3_6_9], [-3.0_5_6_4, -2.4_7_8_0, -2.0_2_0_7], [-2.6_8_8_9, -1.9_2_9_8, -1.7_6_4_0]],
								    ]	,	device=_lowerCamelCase	,	)

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






	@slow
	def 				_lowercase(						self					)    ->    Dict:
								UpperCAmelCase  :	Optional[Any]							  =	MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""					)
								UpperCAmelCase  :	Optional[Any]							  =	model.to(_lowerCamelCase					)

								UpperCAmelCase  :	Any							  =	MobileViTImageProcessor.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""					)

								UpperCAmelCase  :	List[Any]							  =	prepare_img()
								UpperCAmelCase  :	Dict							  =	image_processor(images=_lowerCamelCase	,	return_tensors="""pt"""					).to(_lowerCamelCase					)

								# forward pass
								with torch.no_grad():
															UpperCAmelCase  :	Tuple							  =	model(**_lowerCamelCase					)

								UpperCAmelCase  :	Tuple							  =	outputs.logits.detach().cpu()

								UpperCAmelCase  :	List[str]							  =	image_processor.post_process_semantic_segmentation(outputs=_lowerCamelCase	,	target_sizes=[(50, 60)]					)
								UpperCAmelCase  :	int							  =	torch.Size((50, 60)					)
								self.assertEqual(segmentation[0].shape	,	_lowerCamelCase					)

								UpperCAmelCase  :	str							  =	image_processor.post_process_semantic_segmentation(outputs=_lowerCamelCase					)
								UpperCAmelCase  :	List[str]							  =	torch.Size((32, 32)					)
								self.assertEqual(segmentation[0].shape	,	_lowerCamelCase					)






'''simple docstring'''




def    __lowerCamelCase						(      _lowercase = "The quick brown fox jumps over the lazy dog"			,       )   ->    bool:
							UpperCAmelCase  :	Union[str, Any]							  =	set()

							# Replace all the whitespace in our sentence
							UpperCAmelCase  :	List[str]							  =	input_str.replace(""" """			,       """"""	)
							for alpha in input_str:
														if "a" <= alpha.lower() <= "z":
																					frequency.add(alpha.lower()	)
							return len(_lowercase	) == 2_6



def    __lowerCamelCase						(      _lowercase = "The quick brown fox jumps over the lazy dog"			,       )   ->    bool:
							UpperCAmelCase  :	Tuple							  =	[False] * 2_6
							for char in input_str:
														if char.islower():
																					UpperCAmelCase  :	Any							  =	True
														elif char.isupper():
																					UpperCAmelCase  :	Union[str, Any]							  =	True
							return all(_lowercase	)



def    __lowerCamelCase						(      _lowercase = "The quick brown fox jumps over the lazy dog"			,       )   ->    bool:
							return len({char for char in input_str.lower() if char.isalpha()}	) == 2_6



def    __lowerCamelCase						(      )   ->    None:
							from timeit import timeit

							UpperCAmelCase  :	str							  =	"""from __main__ import is_pangram, is_pangram_faster, is_pangram_fastest"""
							print(timeit("""is_pangram()"""			,       setup=_lowercase	)	)
							print(timeit("""is_pangram_faster()"""			,       setup=_lowercase	)	)
							print(timeit("""is_pangram_fastest()"""			,       setup=_lowercase	)	)
							# 5.348480500048026, 2.6477354579837993, 1.8470395830227062
							# 5.036091582966037, 2.644472333951853,  1.8869528750656173


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							benchmark()

