
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        lowercase      (	_SCREAMING_SNAKE_CASE     ):



		def __UpperCamelCase				(				self )						->      List[str]:
				"""simple docstring"""
				UpperCamelCase						=  self.config_class(**self.inputs_dict )
				self.parent.assertTrue(hasattr(A_       ,   'width_multiplier' ) )






class        lowercase      :



		def __init__(				self       ,   A_       ,   A_=13       ,   A_=64       ,   A_=2       ,   A_=3       ,   A_="swish"       ,   A_=3       ,   A_=32       ,   A_=0.1       ,   A_=0.02       ,   A_=True       ,   A_=True       ,   A_=10       ,   A_=None       ,   A_=0.25       ,   A_=0.0       ,   A_=0.0       ,   )						->      Dict:
				"""simple docstring"""
				UpperCamelCase						=  parent
				UpperCamelCase						=  batch_size
				UpperCamelCase						=  image_size
				UpperCamelCase						=  patch_size
				UpperCamelCase						=  num_channels
				UpperCamelCase						=  make_divisible(512 * width_multiplier       ,   divisor=8 )
				UpperCamelCase						=  hidden_act
				UpperCamelCase						=  conv_kernel_size
				UpperCamelCase						=  output_stride
				UpperCamelCase						=  classifier_dropout_prob
				UpperCamelCase						=  use_labels
				UpperCamelCase						=  is_training
				UpperCamelCase						=  num_labels
				UpperCamelCase						=  initializer_range
				UpperCamelCase						=  scope
				UpperCamelCase						=  width_multiplier
				UpperCamelCase						=  ffn_dropout
				UpperCamelCase						=  attn_dropout



		def __UpperCamelCase				(				self )						->      int:
				"""simple docstring"""
				UpperCamelCase						=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

				UpperCamelCase						=  None
				UpperCamelCase						=  None
				if self.use_labels:
						UpperCamelCase						=  ids_tensor([self.batch_size]       ,   self.num_labels )
						UpperCamelCase						=  ids_tensor([self.batch_size, self.image_size, self.image_size]       ,   self.num_labels )

				UpperCamelCase						=  self.get_config()

				return config, pixel_values, labels, pixel_labels



		def __UpperCamelCase				(				self )						->      Optional[int]:
				"""simple docstring"""
				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 __UpperCamelCase				(				self       ,   A_       ,   A_       ,   A_       ,   A_ )						->      List[Any]:
				"""simple docstring"""
				UpperCamelCase						=  MobileViTVaModel(config=A_ )
				model.to(A_ )
				model.eval()
				UpperCamelCase						=  model(A_ )
				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 __UpperCamelCase				(				self       ,   A_       ,   A_       ,   A_       ,   A_ )						->      str:
				"""simple docstring"""
				UpperCamelCase						=  self.num_labels
				UpperCamelCase						=  MobileViTVaForImageClassification(A_ )
				model.to(A_ )
				model.eval()
				UpperCamelCase						=  model(A_       ,   labels=A_ )
				self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.num_labels) )



		def __UpperCamelCase				(				self       ,   A_       ,   A_       ,   A_       ,   A_ )						->      Tuple:
				"""simple docstring"""
				UpperCamelCase						=  self.num_labels
				UpperCamelCase						=  MobileViTVaForSemanticSegmentation(A_ )
				model.to(A_ )
				model.eval()
				UpperCamelCase						=  model(A_ )
				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						=  model(A_       ,   labels=A_ )
				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 __UpperCamelCase				(				self )						->      int:
				"""simple docstring"""
				UpperCamelCase						=  self.prepare_config_and_inputs()
				UpperCamelCase			,						UpperCamelCase			,						UpperCamelCase			,						UpperCamelCase						=  config_and_inputs
				UpperCamelCase						=  {'pixel_values': pixel_values}
				return config, inputs_dict






@require_torch
class        lowercase      (	_SCREAMING_SNAKE_CASE						,     _SCREAMING_SNAKE_CASE						,     unittest.TestCase     ):
		__lowercase : int			  =       (
		    (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
		    if is_torch_available()
		    else ()
		)

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

		__lowercase : str			  =       False
		__lowercase : int			  =       False
		__lowercase : Optional[int]			  =       False
		__lowercase : Optional[Any]			  =       False



		def __UpperCamelCase				(				self )						->      Dict:
				"""simple docstring"""
				UpperCamelCase						=  MobileViTVaModelTester(self )
				UpperCamelCase						=  MobileViTVaConfigTester(self       ,   config_class=A_       ,   has_text_modality=A_ )



		def __UpperCamelCase				(				self )						->      List[str]:
				"""simple docstring"""
				self.config_tester.run_common_tests()



		@unittest.skip(reason='MobileViTV2 does not use inputs_embeds' )
		def __UpperCamelCase				(				self )						->      Dict:
				"""simple docstring"""
				pass



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



		@unittest.skip(reason='MobileViTV2 does not output attentions' )
		def __UpperCamelCase				(				self )						->      Optional[Any]:
				"""simple docstring"""
				pass



		@require_torch_multi_gpu
		@unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.' )
		def __UpperCamelCase				(				self )						->      int:
				"""simple docstring"""
				pass



		@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' )
		def __UpperCamelCase				(				self )						->      List[str]:
				"""simple docstring"""
				pass



		def __UpperCamelCase				(				self )						->      List[Any]:
				"""simple docstring"""
				UpperCamelCase			,						UpperCamelCase						=  self.model_tester.prepare_config_and_inputs_for_common()

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

						UpperCamelCase						=  ['pixel_values']
						self.assertListEqual(arg_names[:1]       ,   A_ )



		def __UpperCamelCase				(				self )						->      Any:
				"""simple docstring"""
				UpperCamelCase						=  self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*A_ )



		def __UpperCamelCase				(				self )						->      str:
				"""simple docstring"""
				def check_hidden_states_output(A_       ,   A_       ,   A_ ):
						UpperCamelCase						=  model_class(A_ )
						model.to(A_ )
						model.eval()

						with torch.no_grad():
								UpperCamelCase						=  model(**self._prepare_for_class(A_       ,   A_ ) )

						UpperCamelCase						=  outputs.hidden_states

						UpperCamelCase						=  5
						self.assertEqual(len(A_ )       ,   A_ )

						# MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
						# with the width and height being successively divided by 2.
						UpperCamelCase						=  2
						for i in range(len(A_ ) ):
								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						=  self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						UpperCamelCase						=  True
						check_hidden_states_output(A_       ,   A_       ,   A_ )

						# check that output_hidden_states also work using config
						del inputs_dict["output_hidden_states"]
						UpperCamelCase						=  True

						check_hidden_states_output(A_       ,   A_       ,   A_ )



		def __UpperCamelCase				(				self )						->      Dict:
				"""simple docstring"""
				UpperCamelCase						=  self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*A_ )



		def __UpperCamelCase				(				self )						->      Optional[Any]:
				"""simple docstring"""
				UpperCamelCase						=  self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_semantic_segmentation(*A_ )



		@slow
		def __UpperCamelCase				(				self )						->      Dict:
				"""simple docstring"""
				for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						UpperCamelCase						=  MobileViTVaModel.from_pretrained(A_ )
						self.assertIsNotNone(A_ )






def    A (      )     ->						int:
		'''simple docstring'''

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


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



		@cached_property
		def __UpperCamelCase				(				self )						->      Any:
				"""simple docstring"""
				return (
				    MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256' )
				    if is_vision_available()
				    else None
				)



		@slow
		def __UpperCamelCase				(				self )						->      str:
				"""simple docstring"""
				UpperCamelCase						=  MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256' ).to(
				    A_ )

				UpperCamelCase						=  self.default_image_processor
				UpperCamelCase						=  prepare_img()
				UpperCamelCase						=  image_processor(images=A_       ,   return_tensors='pt' ).to(A_ )

				# forward pass
				with torch.no_grad():
						UpperCamelCase						=  model(**A_ )

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

				UpperCamelCase						=  torch.tensor([-1.6336e00, -7.3204e-02, -5.1883e-01] ).to(A_ )

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



		@slow
		def __UpperCamelCase				(				self )						->      List[Any]:
				"""simple docstring"""
				UpperCamelCase						=  MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3' )
				UpperCamelCase						=  model.to(A_ )

				UpperCamelCase						=  MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3' )

				UpperCamelCase						=  prepare_img()
				UpperCamelCase						=  image_processor(images=A_       ,   return_tensors='pt' ).to(A_ )

				# forward pass
				with torch.no_grad():
						UpperCamelCase						=  model(**A_ )
				UpperCamelCase						=  outputs.logits

				# verify the logits
				UpperCamelCase						=  torch.Size((1, 21, 32, 32) )
				self.assertEqual(logits.shape       ,   A_ )

				UpperCamelCase						=  torch.tensor(
				    [
				        [[7.0863, 7.1525, 6.8201], [6.6931, 6.8770, 6.8933], [6.2978, 7.0366, 6.9636]],
				        [[-3.7134, -3.6712, -3.6675], [-3.5825, -3.3549, -3.4777], [-3.3435, -3.3979, -3.2857]],
				        [[-2.9329, -2.8003, -2.7369], [-3.0564, -2.4780, -2.0207], [-2.6889, -1.9298, -1.7640]],
				    ]       ,   device=A_       ,   )

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



		@slow
		def __UpperCamelCase				(				self )						->      List[Any]:
				"""simple docstring"""
				UpperCamelCase						=  MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3' )
				UpperCamelCase						=  model.to(A_ )

				UpperCamelCase						=  MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3' )

				UpperCamelCase						=  prepare_img()
				UpperCamelCase						=  image_processor(images=A_       ,   return_tensors='pt' ).to(A_ )

				# forward pass
				with torch.no_grad():
						UpperCamelCase						=  model(**A_ )

				UpperCamelCase						=  outputs.logits.detach().cpu()

				UpperCamelCase						=  image_processor.post_process_semantic_segmentation(outputs=A_       ,   target_sizes=[(50, 60)] )
				UpperCamelCase						=  torch.Size((50, 60) )
				self.assertEqual(segmentation[0].shape       ,   A_ )

				UpperCamelCase						=  image_processor.post_process_semantic_segmentation(outputs=A_ )
				UpperCamelCase						=  torch.Size((32, 32) )
				self.assertEqual(segmentation[0].shape       ,   A_ )


from google.protobuf import descriptor as _descriptor
from google.protobuf import descriptor_pool as _descriptor_pool
from google.protobuf import symbol_database as _symbol_database
from google.protobuf.internal import builder as _builder


# @@protoc_insertion_point(imports)

_UpperCAmelCase      :				Tuple          = _symbol_database.Default()


_UpperCAmelCase      :				List[Any]          = _descriptor_pool.Default().AddSerializedFile(
    b"\n\x19sentencepiece_model.proto\x12\rsentencepiece\"\x80\x0c\n\x0bTrainerSpec\x12\r\n\x05input\x18\x01 \x03(\t\x12\x14\n\x0cinput_format\x18\x07 \x01(\t\x12\x14\n\x0cmodel_prefix\x18\x02 \x01(\t\x12\x41\n\nmodel_type\x18\x03 \x01(\x0e\x32$.sentencepiece.TrainerSpec.ModelType:\x07UNIGRAM\x12\x18\n\nvocab_size\x18\x04 \x01(\x05:\x04\x38\x30\x30\x30\x12\x17\n\x0f\x61\x63\x63\x65pt_language\x18\x05 \x03(\t\x12 \n\x15self_test_sample_size\x18\x06 \x01(\x05:\x01\x30\x12*\n\x1b\x65nable_differential_privacy\x18\x32 \x01(\x08:\x05\x66\x61lse\x12+\n differential_privacy_noise_level\x18\x33 \x01(\x02:\x01\x30\x12\x32\n\'differential_privacy_clipping_threshold\x18\x34 \x01(\x04:\x01\x30\x12\"\n\x12\x63haracter_coverage\x18\n \x01(\x02:\x06\x30.9995\x12\x1e\n\x13input_sentence_size\x18\x0b \x01(\x04:\x01\x30\x12$\n\x16shuffle_input_sentence\x18\x13 \x01(\x08:\x04true\x12 \n\x14mining_sentence_size\x18\x0c \x01(\x05\x42\x02\x18\x01\x12\"\n\x16training_sentence_size\x18\r \x01(\x05\x42\x02\x18\x01\x12(\n\x17seed_sentencepiece_size\x18\x0e \x01(\x05:\x07\x31\x30\x30\x30\x30\x30\x30\x12\x1e\n\x10shrinking_factor\x18\x0f \x01(\x02:\x04\x30.75\x12!\n\x13max_sentence_length\x18\x12 \x01(\x05:\x04\x34\x31\x39\x32\x12\x17\n\x0bnum_threads\x18\x10 \x01(\x05:\x02\x31\x36\x12\x1d\n\x12num_sub_iterations\x18\x11 \x01(\x05:\x01\x32\x12$\n\x18max_sentencepiece_length\x18\x14 \x01(\x05:\x02\x31\x36\x12%\n\x17split_by_unicode_script\x18\x15 \x01(\x08:\x04true\x12\x1d\n\x0fsplit_by_number\x18\x17 \x01(\x08:\x04true\x12!\n\x13split_by_whitespace\x18\x16 \x01(\x08:\x04true\x12)\n\x1atreat_whitespace_as_suffix\x18\x18 \x01(\x08:\x05\x66\x61lse\x12+\n\x1c\x61llow_whitespace_only_pieces\x18\x1a \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x0csplit_digits\x18\x19 \x01(\x08:\x05\x66\x61lse\x12#\n\x19pretokenization_delimiter\x18\x35 \x01(\t:\x00\x12\x17\n\x0f\x63ontrol_symbols\x18\x1e \x03(\t\x12\x1c\n\x14user_defined_symbols\x18\x1f \x03(\t\x12\x16\n\x0erequired_chars\x18$ \x01(\t\x12\x1c\n\rbyte_fallback\x18# \x01(\x08:\x05\x66\x61lse\x12+\n\x1dvocabulary_output_piece_score\x18  \x01(\x08:\x04true\x12\x1e\n\x10hard_vocab_limit\x18! \x01(\x08:\x04true\x12\x1c\n\ruse_all_vocab\x18\" \x01(\x08:\x05\x66\x61lse\x12\x11\n\x06unk_id\x18( \x01(\x05:\x01\x30\x12\x11\n\x06\x62os_id\x18) \x01(\x05:\x01\x31\x12\x11\n\x06\x65os_id\x18* \x01(\x05:\x01\x32\x12\x12\n\x06pad_id\x18+ \x01(\x05:\x02-1\x12\x18\n\tunk_piece\x18- \x01(\t:\x05<unk>\x12\x16\n\tbos_piece\x18. \x01(\t:\x03<s>\x12\x17\n\teos_piece\x18/ \x01(\t:\x04</s>\x12\x18\n\tpad_piece\x18\x30 \x01(\t:\x05<pad>\x12\x1a\n\x0bunk_surface\x18, \x01(\t:\x05 \xe2\x81\x87 \x12+\n\x1ctrain_extremely_large_corpus\x18\x31 \x01(\x08:\x05\x66\x61lse\"5\n\tModelType\x12\x0b\n\x07UNIGRAM\x10\x01\x12\x07\n\x03\x42PE\x10\x02\x12\x08\n\x04WORD\x10\x03\x12\x08\n\x04\x43HAR\x10\x04*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\"\xd1\x01\n\x0eNormalizerSpec\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1c\n\x14precompiled_charsmap\x18\x02 \x01(\x0c\x12\x1e\n\x10\x61\x64\x64_dummy_prefix\x18\x03 \x01(\x08:\x04true\x12&\n\x18remove_extra_whitespaces\x18\x04 \x01(\x08:\x04true\x12 \n\x12\x65scape_whitespaces\x18\x05 \x01(\x08:\x04true\x12\x1e\n\x16normalization_rule_tsv\x18\x06 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\"y\n\x0cSelfTestData\x12\x33\n\x07samples\x18\x01 \x03(\x0b\x32\".sentencepiece.SelfTestData.Sample\x1a)\n\x06Sample\x12\r\n\x05input\x18\x01 \x01(\t\x12\x10\n\x08\x65xpected\x18\x02 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\"\xfe\x03\n\nModelProto\x12\x37\n\x06pieces\x18\x01 \x03(\x0b\x32\'.sentencepiece.ModelProto.SentencePiece\x12\x30\n\x0ctrainer_spec\x18\x02 \x01(\x0b\x32\x1a.sentencepiece.TrainerSpec\x12\x36\n\x0fnormalizer_spec\x18\x03 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x12\x33\n\x0eself_test_data\x18\x04 \x01(\x0b\x32\x1b.sentencepiece.SelfTestData\x12\x38\n\x11\x64\x65normalizer_spec\x18\x05 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x1a\xd2\x01\n\rSentencePiece\x12\r\n\x05piece\x18\x01 \x01(\t\x12\r\n\x05score\x18\x02 \x01(\x02\x12\x42\n\x04type\x18\x03 \x01(\x0e\x32,.sentencepiece.ModelProto.SentencePiece.Type:\x06NORMAL\"T\n\x04Type\x12\n\n\x06NORMAL\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\x12\x0b\n\x07\x43ONTROL\x10\x03\x12\x10\n\x0cUSER_DEFINED\x10\x04\x12\x08\n\x04\x42YTE\x10\x06\x12\n\n\x06UNUSED\x10\x05*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\x42\x02H\x03"
)

_UpperCAmelCase      :				int          = globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "sentencepiece_model_pb2", _globals)
if _descriptor._USE_C_DESCRIPTORS is False:
					_UpperCAmelCase      :				int          = None
					_UpperCAmelCase      :				List[str]          = b"H\003"
					# (generated by protobuf compiler, but `_TRAINERSPEC` is not defined)
					# _TRAINERSPEC.fields_by_name["mining_sentence_size"]._options = None
					# _TRAINERSPEC.fields_by_name["mining_sentence_size"]._serialized_options = b"\030\001"
					# _TRAINERSPEC.fields_by_name["training_sentence_size"]._options = None
					# _TRAINERSPEC.fields_by_name["training_sentence_size"]._serialized_options = b"\030\001"
					_UpperCAmelCase      :				Optional[Any]          = 45
					_UpperCAmelCase      :				Any          = 1_581
					_UpperCAmelCase      :				Tuple          = 1_517
					_UpperCAmelCase      :				List[str]          = 1_570
					_UpperCAmelCase      :				int          = 1_584
					_UpperCAmelCase      :				List[Any]          = 1_793
					_UpperCAmelCase      :				Optional[int]          = 1_795
					_UpperCAmelCase      :				Any          = 1_916
					_UpperCAmelCase      :				Tuple          = 1_864
					_UpperCAmelCase      :				List[Any]          = 1_905
					_UpperCAmelCase      :				Union[str, Any]          = 1_919
					_UpperCAmelCase      :				str          = 2_429
					_UpperCAmelCase      :				Any          = 2_208
					_UpperCAmelCase      :				Dict          = 2_418
					_UpperCAmelCase      :				Optional[Any]          = 2_323
					_UpperCAmelCase      :				Tuple          = 2_407
# @@protoc_insertion_point(module_scope)
