
'''simple docstring'''

import argparse
import os
import re

import numpy as np
import PIL
import torch
from timm import create_model
from torch.optim.lr_scheduler import OneCycleLR
from torch.utils.data import DataLoader, Dataset
from torchvision.transforms import Compose, RandomResizedCrop, Resize, ToTensor

from accelerate import Accelerator







def 	A  (   UpperCamelCase_       :  Dict   )       ->							Tuple:







			'''simple docstring'''



			lowerCAmelCase__										=				fname.split(os.path.sep   )[-1]
			return re.search(r"^(.*)_\d+\.jpg$"    ,						UpperCamelCase_   ).groups()[0]






class  A  (						SCREAMING_SNAKE_CASE__     ):





	def __init__(       self      :							List[Any]   ,				__magic_name__      :							Dict   ,				__magic_name__      :							Any=None   ,				__magic_name__      :							List[Any]=None				):


				"""simple docstring"""

				lowerCAmelCase__										=				file_names
				lowerCAmelCase__										=				image_transform
				lowerCAmelCase__										=				label_to_id





	def __len__(       self      :							Any				):


				"""simple docstring"""

				return len(self.file_names				)







	def __getitem__(       self      :							List[Any]   ,				__magic_name__      :							List[Any]				):


				"""simple docstring"""

				lowerCAmelCase__										=				self.file_names[idx]
				lowerCAmelCase__										=				PIL.Image.open(__magic_name__				)
				lowerCAmelCase__										=				raw_image.convert("RGB"				)
				if self.image_transform is not None:
							lowerCAmelCase__										=				self.image_transform(__magic_name__				)
				lowerCAmelCase__										=				extract_label(__magic_name__				)
				if self.label_to_id is not None:
							lowerCAmelCase__										=				self.label_to_id[label]
				return {"image": image, "label": label}







def 	A  (   UpperCamelCase_       :  Tuple    ,						UpperCamelCase_       :  List[str]   )       ->							List[str]:







			'''simple docstring'''



			if args.with_tracking:
						lowerCAmelCase__										=				Accelerator(
						    cpu=args.cpu    ,						mixed_precision=args.mixed_precision    ,						log_with="all"    ,						project_dir=args.project_dir   )
			else:
						lowerCAmelCase__										=				Accelerator(cpu=args.cpu    ,						mixed_precision=args.mixed_precision   )

			# Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
			lowerCAmelCase__										=				config["lr"]
			lowerCAmelCase__										=				int(config["num_epochs"]   )
			lowerCAmelCase__										=				int(config["seed"]   )
			lowerCAmelCase__										=				int(config["batch_size"]   )
			lowerCAmelCase__										=				config["image_size"]
			if not isinstance(UpperCamelCase_    ,						(list, tuple)   ):
						lowerCAmelCase__										=				(image_size, image_size)

			# Parse out whether we are saving every epoch or after a certain number of batches
			if hasattr(args.checkpointing_steps    ,						"isdigit"   ):
						if args.checkpointing_steps == "epoch":
									lowerCAmelCase__										=				args.checkpointing_steps
						elif args.checkpointing_steps.isdigit():
									lowerCAmelCase__										=				int(args.checkpointing_steps   )
						else:
									raise ValueError(
									    F"""Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed."""   )
			else:
						lowerCAmelCase__										=				None

			# We need to initialize the trackers we use, and also store our configuration
			if args.with_tracking:
						lowerCAmelCase__										=				os.path.split(UpperCamelCase_   )[-1].split("."   )[0]
						accelerator.init_trackers(UpperCamelCase_    ,						UpperCamelCase_   )

			# Grab all the image filenames
			lowerCAmelCase__										=				[os.path.join(args.data_dir    ,						UpperCamelCase_   ) for fname in os.listdir(args.data_dir   ) if fname.endswith(".jpg"   )]

			# Build the label correspondences
			lowerCAmelCase__										=				[extract_label(UpperCamelCase_   ) for fname in file_names]
			lowerCAmelCase__										=				list(set(UpperCamelCase_   )   )
			id_to_label.sort()
			lowerCAmelCase__										=				{lbl: i for i, lbl in enumerate(UpperCamelCase_   )}

			# Set the seed before splitting the data.
			np.random.seed(UpperCamelCase_   )
			torch.manual_seed(UpperCamelCase_   )
			torch.cuda.manual_seed_all(UpperCamelCase_   )

			# Split our filenames between train and validation
			lowerCAmelCase__										=				np.random.permutation(len(UpperCamelCase_   )   )
			lowerCAmelCase__										=				int(0.8 * len(UpperCamelCase_   )   )
			lowerCAmelCase__										=				random_perm[:cut]
			lowerCAmelCase__										=				random_perm[cut:]

			# For training we use a simple RandomResizedCrop
			lowerCAmelCase__										=				Compose([RandomResizedCrop(UpperCamelCase_    ,						scale=(0.5, 1.0)   ), ToTensor()]   )
			lowerCAmelCase__										=				PetsDataset(
			    [file_names[i] for i in train_split]    ,						image_transform=UpperCamelCase_    ,						label_to_id=UpperCamelCase_   )

			# For evaluation, we use a deterministic Resize
			lowerCAmelCase__										=				Compose([Resize(UpperCamelCase_   ), ToTensor()]   )
			lowerCAmelCase__										=				PetsDataset([file_names[i] for i in eval_split]    ,						image_transform=UpperCamelCase_    ,						label_to_id=UpperCamelCase_   )

			# Instantiate dataloaders.
			lowerCAmelCase__										=				DataLoader(UpperCamelCase_    ,						shuffle=UpperCamelCase_    ,						batch_size=UpperCamelCase_    ,						num_workers=4   )
			lowerCAmelCase__										=				DataLoader(UpperCamelCase_    ,						shuffle=UpperCamelCase_    ,						batch_size=UpperCamelCase_    ,						num_workers=4   )

			# Instantiate the model (we build the model here so that the seed also control new weights initialization)
			lowerCAmelCase__										=				create_model("resnet50d"    ,						pretrained=UpperCamelCase_    ,						num_classes=len(UpperCamelCase_   )   )

			# We could avoid this line since the accelerator is set with `device_placement=True` (default value).
			# Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer
			# creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).
			lowerCAmelCase__										=				model.to(accelerator.device   )

			# Freezing the base model
			for param in model.parameters():
						lowerCAmelCase__										=				False
			for param in model.get_classifier().parameters():
						lowerCAmelCase__										=				True

			# We normalize the batches of images to be a bit faster.
			lowerCAmelCase__										=				torch.tensor(model.default_cfg["mean"]   )[None, :, None, None].to(accelerator.device   )
			lowerCAmelCase__										=				torch.tensor(model.default_cfg["std"]   )[None, :, None, None].to(accelerator.device   )

			# Instantiate optimizer
			lowerCAmelCase__										=				torch.optim.Adam(params=model.parameters()    ,						lr=lr / 25   )

			# Instantiate learning rate scheduler
			lowerCAmelCase__										=				OneCycleLR(optimizer=UpperCamelCase_    ,						max_lr=UpperCamelCase_    ,						epochs=UpperCamelCase_    ,						steps_per_epoch=len(UpperCamelCase_   )   )

			# Prepare everything
			# There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
			# prepare method.
			lowerCAmelCase__						,lowerCAmelCase__						,lowerCAmelCase__						,lowerCAmelCase__						,lowerCAmelCase__										=				accelerator.prepare(
			    UpperCamelCase_    ,						UpperCamelCase_    ,						UpperCamelCase_    ,						UpperCamelCase_    ,						UpperCamelCase_   )
			# We need to keep track of how many total steps we have iterated over
			lowerCAmelCase__										=				0
			# We also need to keep track of the starting epoch so files are named properly
			lowerCAmelCase__										=				0

			# Potentially load in the weights and states from a previous save
			if args.resume_from_checkpoint:
						if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
									accelerator.print(F"""Resumed from checkpoint: {args.resume_from_checkpoint}"""   )
									accelerator.load_state(args.resume_from_checkpoint   )
									lowerCAmelCase__										=				os.path.basename(args.resume_from_checkpoint   )
						else:
									# Get the most recent checkpoint
									lowerCAmelCase__										=				[f.name for f in os.scandir(os.getcwd()   ) if f.is_dir()]
									dirs.sort(key=os.path.getctime   )
									lowerCAmelCase__										=				dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
						# Extract `epoch_{i}` or `step_{i}`
						lowerCAmelCase__										=				os.path.splitext(UpperCamelCase_   )[0]

						if "epoch" in training_difference:
									lowerCAmelCase__										=				int(training_difference.replace("epoch_"    ,						""   )   ) + 1
									lowerCAmelCase__										=				None
						else:
									lowerCAmelCase__										=				int(training_difference.replace("step_"    ,						""   )   )
									lowerCAmelCase__										=				resume_step // len(UpperCamelCase_   )
									resume_step -= starting_epoch * len(UpperCamelCase_   )

    # Now we train the model
			for epoch in range(UpperCamelCase_    ,						UpperCamelCase_   ):
						model.train()
						if args.with_tracking:
									lowerCAmelCase__										=				0
						if args.resume_from_checkpoint and epoch == starting_epoch and resume_step is not None:
									# We need to skip steps until we reach the resumed step
									lowerCAmelCase__										=				accelerator.skip_first_batches(UpperCamelCase_    ,						UpperCamelCase_   )
									overall_step += resume_step
						else:
									# After the first iteration though, we need to go back to the original dataloader
									lowerCAmelCase__										=				train_dataloader
						for batch in active_dataloader:
									# We could avoid this line since we set the accelerator with `device_placement=True`.
									lowerCAmelCase__										=				{k: v.to(accelerator.device   ) for k, v in batch.items()}
									lowerCAmelCase__										=				(batch["image"] - mean) / std
									lowerCAmelCase__										=				model(UpperCamelCase_   )
									lowerCAmelCase__										=				torch.nn.functional.cross_entropy(UpperCamelCase_    ,						batch["label"]   )
									# We keep track of the loss at each epoch
									if args.with_tracking:
												total_loss += loss.detach().float()
									accelerator.backward(UpperCamelCase_   )
									optimizer.step()
									lr_scheduler.step()
									optimizer.zero_grad()
									overall_step += 1
									if isinstance(UpperCamelCase_    ,						UpperCamelCase_   ):
												lowerCAmelCase__										=				F"""step_{overall_step}"""
												if overall_step % checkpointing_steps == 0:
															if args.output_dir is not None:
																		lowerCAmelCase__										=				os.path.join(args.output_dir    ,						UpperCamelCase_   )
															accelerator.save_state(UpperCamelCase_   )
						model.eval()
						lowerCAmelCase__										=				0
						lowerCAmelCase__										=				0
						for step, batch in enumerate(UpperCamelCase_   ):
									# We could avoid this line since we set the accelerator with `device_placement=True`.
									lowerCAmelCase__										=				{k: v.to(accelerator.device   ) for k, v in batch.items()}
									lowerCAmelCase__										=				(batch["image"] - mean) / std
									with torch.no_grad():
												lowerCAmelCase__										=				model(UpperCamelCase_   )
									lowerCAmelCase__										=				outputs.argmax(dim=-1   )
									lowerCAmelCase__						,lowerCAmelCase__										=				accelerator.gather_for_metrics((predictions, batch["label"])   )
									lowerCAmelCase__										=				predictions == references
									num_elems += accurate_preds.shape[0]
									accurate += accurate_preds.long().sum()

						lowerCAmelCase__										=				accurate.item() / num_elems
						# Use accelerator.print to print only on the main process.
						accelerator.print(F"""epoch {epoch}: {1_00 * eval_metric:.2f}"""   )
						if args.with_tracking:
									accelerator.log(
									    {
									        "accuracy": 1_00 * eval_metric,
									        "train_loss": total_loss.item() / len(UpperCamelCase_   ),
									        "epoch": epoch,
									    }    ,						step=UpperCamelCase_    ,						)
						if checkpointing_steps == "epoch":
									lowerCAmelCase__										=				F"""epoch_{epoch}"""
									if args.output_dir is not None:
												lowerCAmelCase__										=				os.path.join(args.output_dir    ,						UpperCamelCase_   )
									accelerator.save_state(UpperCamelCase_   )

			if args.with_tracking:
						accelerator.end_training()







def 	A  (   )       ->							Optional[int]:







			'''simple docstring'''



			lowerCAmelCase__										=				argparse.ArgumentParser(description="Simple example of training script."   )
			parser.add_argument("--data_dir"    ,						required=UpperCamelCase_    ,						help="The data folder on disk."   )
			parser.add_argument("--fp16"    ,						action="store_true"    ,						help="If passed, will use FP16 training."   )
			parser.add_argument(
			    "--mixed_precision"    ,						type=UpperCamelCase_    ,						default=UpperCamelCase_    ,						choices=["no", "fp16", "bf16", "fp8"]    ,						help="Whether to use mixed precision. Choose"
			    "between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10."
			    "and an Nvidia Ampere GPU."    ,						)
			parser.add_argument("--cpu"    ,						action="store_true"    ,						help="If passed, will train on the CPU."   )
			parser.add_argument(
			    "--checkpointing_steps"    ,						type=UpperCamelCase_    ,						default=UpperCamelCase_    ,						help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch."    ,						)
			parser.add_argument(
			    "--output_dir"    ,						type=UpperCamelCase_    ,						default="."    ,						help="Optional save directory where all checkpoint folders will be stored. Default is the current working directory."    ,						)
			parser.add_argument(
			    "--resume_from_checkpoint"    ,						type=UpperCamelCase_    ,						default=UpperCamelCase_    ,						help="If the training should continue from a checkpoint folder."    ,						)
			parser.add_argument(
			    "--with_tracking"    ,						action="store_true"    ,						help="Whether to load in all available experiment trackers from the environment and use them for logging."    ,						)
			parser.add_argument(
			    "--project_dir"    ,						type=UpperCamelCase_    ,						default="logs"    ,						help="Location on where to store experiment tracking logs` and relevent project information"    ,						)
			lowerCAmelCase__										=				parser.parse_args()
			lowerCAmelCase__										=				{"lr": 3E-2, "num_epochs": 3, "seed": 42, "batch_size": 64, "image_size": 2_24}
			training_function(UpperCamelCase_    ,						UpperCamelCase_   )


if __name__ == "__main__":
		main()











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)

SCREAMING_SNAKE_CASE:     str									= _symbol_database.Default()


SCREAMING_SNAKE_CASE:     Dict									= _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'''
)

SCREAMING_SNAKE_CASE:     Optional[Any]									= globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, '''sentencepiece_model_pb2''', _globals)
if _descriptor._USE_C_DESCRIPTORS is False:
						SCREAMING_SNAKE_CASE:     List[Any]									= None
						SCREAMING_SNAKE_CASE:     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"
						SCREAMING_SNAKE_CASE:     List[Any]									= 4_5
						SCREAMING_SNAKE_CASE:     List[Any]									= 1_5_8_1
						SCREAMING_SNAKE_CASE:     Union[str, Any]									= 1_5_1_7
						SCREAMING_SNAKE_CASE:     Any									= 1_5_7_0
						SCREAMING_SNAKE_CASE:     Union[str, Any]									= 1_5_8_4
						SCREAMING_SNAKE_CASE:     str									= 1_7_9_3
						SCREAMING_SNAKE_CASE:     List[Any]									= 1_7_9_5
						SCREAMING_SNAKE_CASE:     Any									= 1_9_1_6
						SCREAMING_SNAKE_CASE:     Optional[Any]									= 1_8_6_4
						SCREAMING_SNAKE_CASE:     Union[str, Any]									= 1_9_0_5
						SCREAMING_SNAKE_CASE:     str									= 1_9_1_9
						SCREAMING_SNAKE_CASE:     Any									= 2_4_2_9
						SCREAMING_SNAKE_CASE:     Dict									= 2_2_0_8
						SCREAMING_SNAKE_CASE:     Optional[Any]									= 2_4_1_8
						SCREAMING_SNAKE_CASE:     Optional[Any]									= 2_3_2_3
						SCREAMING_SNAKE_CASE:     Tuple									= 2_4_0_7
# @@protoc_insertion_point(module_scope)