





import importlib.metadata
import warnings
from copy import deepcopy

from packaging import version

from ..utils import logging
from .import_utils import is_accelerate_available, is_bitsandbytes_available


if is_bitsandbytes_available():
						import bitsandbytes as bnb
						import torch
						import torch.nn as nn

						from ..pytorch_utils import ConvaD

if is_accelerate_available():
						from accelerate import init_empty_weights
						from accelerate.utils import find_tied_parameters

__lowercase       :List[str]       =  logging.get_logger(__name__)







def       UpperCAmelCase							(     _lowerCamelCase      :  str			,   _lowerCamelCase      :  Dict			,   _lowerCamelCase      :  str			,   _lowerCamelCase      :  Optional[int]=None			,   _lowerCamelCase      :  Optional[int]=None     ):





						'''simple docstring'''


						if "." in tensor_name:
												SCREAMING_SNAKE_CASE__     :				Optional[int]   =					tensor_name.split("."     )
												for split in splits[:-1]:
																		SCREAMING_SNAKE_CASE__     :				List[Any]   =					getattr(_lowerCamelCase			,   _lowerCamelCase     )
																		if new_module is None:
																								raise ValueError(f"""{module} has no attribute {split}."""     )
																		SCREAMING_SNAKE_CASE__     :				Any   =					new_module
												SCREAMING_SNAKE_CASE__     :				int   =					splits[-1]

						if tensor_name not in module._parameters and tensor_name not in module._buffers:
												raise ValueError(f"""{module} does not have a parameter or a buffer named {tensor_name}."""     )
						SCREAMING_SNAKE_CASE__     :				int   =					tensor_name in module._buffers
						SCREAMING_SNAKE_CASE__     :				Tuple   =					getattr(_lowerCamelCase			,   _lowerCamelCase     )

						if old_value.device == torch.device("meta"     ) and device not in ["meta", torch.device("meta"     )] and value is None:
												raise ValueError(f"""{tensor_name} is on the meta device, we need a `value` to put in on {device}."""     )

						SCREAMING_SNAKE_CASE__     :				str   =					False
						SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					False
						if is_buffer or not is_bitsandbytes_available():
												SCREAMING_SNAKE_CASE__     :				List[Any]   =					False
												SCREAMING_SNAKE_CASE__     :				int   =					False
						else:
												SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					hasattr(bnb.nn			,   "Params4bit"     ) and isinstance(module._parameters[tensor_name]			,   bnb.nn.Paramsabit     )
												SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					isinstance(module._parameters[tensor_name]			,   bnb.nn.IntaParams     )

						if is_abit or is_abit:
												SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					module._parameters[tensor_name]
												if param.device.type != "cuda":
																		if value is None:
																								SCREAMING_SNAKE_CASE__     :				Dict   =					old_value.to(_lowerCamelCase     )
																		elif isinstance(_lowerCamelCase			,   torch.Tensor     ):
																								SCREAMING_SNAKE_CASE__     :				int   =					value.to("cpu"     )
																								if value.dtype == torch.inta:
																														SCREAMING_SNAKE_CASE__     :				List[Any]   =					version.parse(importlib.metadata.version("bitsandbytes"     )     ) > version.parse(
																														    "0.37.2"     )
																														if not is_abit_serializable:
																																				raise ValueError(
																																				    "Detected int8 weights but the version of bitsandbytes is not compatible with int8 serialization. "
																																				    "Make sure to download the latest `bitsandbytes` version. `pip install --upgrade bitsandbytes`."     )
																		else:
																								SCREAMING_SNAKE_CASE__     :				Any   =					torch.tensor(_lowerCamelCase			,   device="cpu"     )

																		# Support models using `Conv1D` in place of `nn.Linear` (e.g. gpt2) by transposing the weight matrix prior to quantization.
																		# Since weights are saved in the correct "orientation", we skip transposing when loading.
																		if issubclass(module.source_cls			,   _lowerCamelCase     ) and fpaa_statistics is None:
																								SCREAMING_SNAKE_CASE__     :				Dict   =					new_value.T

																		SCREAMING_SNAKE_CASE__     :				int   =					old_value.__dict__
																		if is_abit:
																								SCREAMING_SNAKE_CASE__     :				Optional[int]   =					bnb.nn.IntaParams(_lowerCamelCase			,   requires_grad=_lowerCamelCase			,   **_lowerCamelCase     ).to(_lowerCamelCase     )
																		elif is_abit:
																								SCREAMING_SNAKE_CASE__     :				List[str]   =					bnb.nn.Paramsabit(_lowerCamelCase			,   requires_grad=_lowerCamelCase			,   **_lowerCamelCase     ).to(_lowerCamelCase     )

																		SCREAMING_SNAKE_CASE__     :				List[str]   =					new_value
																		if fpaa_statistics is not None:
																								setattr(module.weight			,   "SCB"			,   fpaa_statistics.to(_lowerCamelCase     )     )

						else:
												if value is None:
																		SCREAMING_SNAKE_CASE__     :				List[str]   =					old_value.to(_lowerCamelCase     )
												elif isinstance(_lowerCamelCase			,   torch.Tensor     ):
																		SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					value.to(_lowerCamelCase     )
												else:
																		SCREAMING_SNAKE_CASE__     :				Any   =					torch.tensor(_lowerCamelCase			,   device=_lowerCamelCase     )

												if is_buffer:
																		SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					new_value
												else:
																		SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					nn.Parameter(_lowerCamelCase			,   requires_grad=old_value.requires_grad     )
																		SCREAMING_SNAKE_CASE__     :				Dict   =					new_value







def       UpperCAmelCase							(     _lowerCamelCase      :  Dict			,   _lowerCamelCase      :  Tuple=None			,   _lowerCamelCase      :  Any=None			,   _lowerCamelCase      :  Tuple=None			,   _lowerCamelCase      :  Union[str, Any]=False     ):





						'''simple docstring'''


						for name, module in model.named_children():
												if current_key_name is None:
																		SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					[]
												current_key_name.append(_lowerCamelCase     )

												if (isinstance(_lowerCamelCase			,   nn.Linear     ) or isinstance(_lowerCamelCase			,   _lowerCamelCase     )) and name not in modules_to_not_convert:
																		# Check if the current key is not in the `modules_to_not_convert`
																		if not any(key in ".".join(_lowerCamelCase     ) for key in modules_to_not_convert     ):
																								with init_empty_weights():
																														if isinstance(_lowerCamelCase			,   _lowerCamelCase     ):
																																				SCREAMING_SNAKE_CASE__     :				List[str]   =					module.weight.shape
																														else:
																																				SCREAMING_SNAKE_CASE__     :				Any   =					module.in_features
																																				SCREAMING_SNAKE_CASE__     :				int   =					module.out_features

																														if quantization_config.quantization_method() == "llm_int8":
																																				SCREAMING_SNAKE_CASE__     :				str   =					bnb.nn.LinearabitLt(
																																				    _lowerCamelCase			,   _lowerCamelCase			,   module.bias is not None			,   has_fpaa_weights=quantization_config.llm_inta_has_fpaa_weight			,   threshold=quantization_config.llm_inta_threshold			,   )
																																				SCREAMING_SNAKE_CASE__     :				Tuple   =					True
																														else:
																																				if (
																																				    quantization_config.llm_inta_skip_modules is not None
																																				    and name in quantization_config.llm_inta_skip_modules
																																				):
																																										pass
																																				else:
																																										SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					bnb.nn.Linearabit(
																																										    _lowerCamelCase			,   _lowerCamelCase			,   module.bias is not None			,   quantization_config.bnb_abit_compute_dtype			,   compress_statistics=quantization_config.bnb_abit_use_double_quant			,   quant_type=quantization_config.bnb_abit_quant_type			,   )
																																										SCREAMING_SNAKE_CASE__     :				str   =					True
                    # Store the module class in case we need to transpose the weight later
																														SCREAMING_SNAKE_CASE__     :				Tuple   =					type(_lowerCamelCase     )
																														# Force requires grad to False to avoid unexpected errors
																														model._modules[name].requires_grad_(_lowerCamelCase     )
												if len(list(module.children()     )     ) > 0:
																		SCREAMING_SNAKE_CASE__     :				List[str]   =					_replace_with_bnb_linear(
																		    _lowerCamelCase			,   _lowerCamelCase			,   _lowerCamelCase			,   _lowerCamelCase			,   has_been_replaced=_lowerCamelCase			,   )
												# Remove the last key for recursion
												current_key_name.pop(-1     )
						return model, has_been_replaced







def       UpperCAmelCase							(     _lowerCamelCase      :  Union[str, Any]			,   _lowerCamelCase      :  Tuple=None			,   _lowerCamelCase      :  int=None			,   _lowerCamelCase      :  str=None     ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					["lm_head"] if modules_to_not_convert is None else modules_to_not_convert
						SCREAMING_SNAKE_CASE__     :				Any   =					_replace_with_bnb_linear(
						    _lowerCamelCase			,   _lowerCamelCase			,   _lowerCamelCase			,   _lowerCamelCase     )

						if not has_been_replaced:
												logger.warning(
												    "You are loading your model in 8bit or 4bit but no linear modules were found in your model."
												    " Please double check your model architecture, or submit an issue on github if you think this is"
												    " a bug."     )

						return model







def       UpperCAmelCase							(     *_lowerCamelCase      :  Dict			,   **_lowerCamelCase      :  List[Any]     ):





						'''simple docstring'''


						warnings.warn(
						    "`replace_8bit_linear` will be deprecated in a future version, please use `replace_with_bnb_linear` instead"			,   _lowerCamelCase			,   )
						return replace_with_bnb_linear(*_lowerCamelCase			,   **_lowerCamelCase     )







def       UpperCAmelCase							(     *_lowerCamelCase      :  Union[str, Any]			,   **_lowerCamelCase      :  Optional[int]     ):





						'''simple docstring'''


						warnings.warn(
						    "`set_module_8bit_tensor_to_device` will be deprecated in a future version, please use `set_module_quantized_tensor_to_device` instead"			,   _lowerCamelCase			,   )
						return set_module_quantized_tensor_to_device(*_lowerCamelCase			,   **_lowerCamelCase     )







def       UpperCAmelCase							(     _lowerCamelCase      :  Tuple     ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__     :				int   =					deepcopy(_lowerCamelCase     )  # this has 0 cost since it is done inside `init_empty_weights` context manager`
						tied_model.tie_weights()

						SCREAMING_SNAKE_CASE__     :				List[str]   =					find_tied_parameters(_lowerCamelCase     )
						# For compatibility with Accelerate < 0.18
						if isinstance(_lowerCamelCase			,   _lowerCamelCase     ):
												SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					sum(list(tied_params.values()     )			,   []     ) + list(tied_params.keys()     )
						else:
												SCREAMING_SNAKE_CASE__     :				Optional[int]   =					sum(_lowerCamelCase			,   []     )
						SCREAMING_SNAKE_CASE__     :				int   =					len(_lowerCamelCase     ) > 0

						# Check if it is a base model
						SCREAMING_SNAKE_CASE__     :				Optional[int]   =					not hasattr(_lowerCamelCase			,   model.base_model_prefix     )

						# Ignore this for base models (BertModel, GPT2Model, etc.)
						if (not has_tied_params) and is_base_model:
												return []

						# otherwise they have an attached head
						SCREAMING_SNAKE_CASE__     :				Optional[int]   =					list(model.named_children()     )
						SCREAMING_SNAKE_CASE__     :				int   =					[list_modules[-1][0]]

						# add last module together with tied weights
						SCREAMING_SNAKE_CASE__     :				int   =					set(_lowerCamelCase     ) - set(_lowerCamelCase     )
						SCREAMING_SNAKE_CASE__     :				Any   =					list(set(_lowerCamelCase     )     ) + list(_lowerCamelCase     )

						# remove ".weight" from the keys
						SCREAMING_SNAKE_CASE__     :				Dict   =					[".weight", ".bias"]
						SCREAMING_SNAKE_CASE__     :				str   =					[]
						for name in list_untouched:
												for name_to_remove in names_to_remove:
																		if name_to_remove in name:
																								SCREAMING_SNAKE_CASE__     :				Any   =					name.replace(_lowerCamelCase			,   ""     )
												filtered_module_names.append(_lowerCamelCase     )

						return filtered_module_names






import logging
import os
from dataclasses import dataclass, field
from typing import Dict, Optional

import datasets
import numpy as np
import tensorflow as tf

from transformers import (
    AutoConfig,
    AutoTokenizer,
    EvalPrediction,
    HfArgumentParser,
    PreTrainedTokenizer,
    TFAutoModelForSequenceClassification,
    TFTrainer,
    TFTrainingArguments,
)
from transformers.utils import logging as hf_logging


hf_logging.set_verbosity_info()
hf_logging.enable_default_handler()
hf_logging.enable_explicit_format()







def       UpperCAmelCase							(     _lowerCamelCase      :  str			,   _lowerCamelCase      :  str			,   _lowerCamelCase      :  str			,   _lowerCamelCase      :  PreTrainedTokenizer			,   _lowerCamelCase      :  int			,   _lowerCamelCase      :  Optional[int] = None			,   ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__     :				str   =					{}

						if train_file is not None:
												SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					[train_file]
						if eval_file is not None:
												SCREAMING_SNAKE_CASE__     :				int   =					[eval_file]
						if test_file is not None:
												SCREAMING_SNAKE_CASE__     :				int   =					[test_file]

						SCREAMING_SNAKE_CASE__     :				Optional[int]   =					datasets.load_dataset("csv"			,   data_files=_lowerCamelCase     )
						SCREAMING_SNAKE_CASE__     :				List[str]   =					list(ds[list(files.keys()     )[0]].features.keys()     )
						SCREAMING_SNAKE_CASE__     :				int   =					features_name.pop(_lowerCamelCase     )
						SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					list(set(ds[list(files.keys()     )[0]][label_name]     )     )
						SCREAMING_SNAKE_CASE__     :				List[str]   =					{label: i for i, label in enumerate(_lowerCamelCase     )}
						SCREAMING_SNAKE_CASE__     :				Optional[int]   =					tokenizer.model_input_names
						SCREAMING_SNAKE_CASE__     :				Any   =					{}

						if len(_lowerCamelCase     ) == 1:
												for k in files.keys():
																		SCREAMING_SNAKE_CASE__     :				List[Any]   =					ds[k].map(
																		    lambda _lowerCamelCase     : tokenizer.batch_encode_plus(
																		        example[features_name[0]]			,   truncation=_lowerCamelCase			,   max_length=_lowerCamelCase			,   padding="max_length"     )			,   batched=_lowerCamelCase			,   )
						elif len(_lowerCamelCase     ) == 2:
												for k in files.keys():
																		SCREAMING_SNAKE_CASE__     :				Any   =					ds[k].map(
																		    lambda _lowerCamelCase     : tokenizer.batch_encode_plus(
																		        (example[features_name[0]], example[features_name[1]])			,   truncation=_lowerCamelCase			,   max_length=_lowerCamelCase			,   padding="max_length"			,   )			,   batched=_lowerCamelCase			,   )

						def gen_train():
												for ex in transformed_ds[datasets.Split.TRAIN]:
																		SCREAMING_SNAKE_CASE__     :				Tuple   =					{k: v for k, v in ex.items() if k in input_names}
																		SCREAMING_SNAKE_CASE__     :				List[Any]   =					labelaid[ex[label_name]]
																		yield (d, label)

						def gen_val():
												for ex in transformed_ds[datasets.Split.VALIDATION]:
																		SCREAMING_SNAKE_CASE__     :				int   =					{k: v for k, v in ex.items() if k in input_names}
																		SCREAMING_SNAKE_CASE__     :				Optional[int]   =					labelaid[ex[label_name]]
																		yield (d, label)

						def gen_test():
												for ex in transformed_ds[datasets.Split.TEST]:
																		SCREAMING_SNAKE_CASE__     :				int   =					{k: v for k, v in ex.items() if k in input_names}
																		SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					labelaid[ex[label_name]]
																		yield (d, label)

						SCREAMING_SNAKE_CASE__     :				Tuple   =					(
						    tf.data.Dataset.from_generator(
						        _lowerCamelCase			,   ({k: tf.intaa for k in input_names}, tf.intaa)			,   ({k: tf.TensorShape([None]     ) for k in input_names}, tf.TensorShape([]     ))			,   )
						    if datasets.Split.TRAIN in transformed_ds
						    else None
						)

						if train_ds is not None:
												SCREAMING_SNAKE_CASE__     :				Any   =					train_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TRAIN]     )     )     )

						SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					(
						    tf.data.Dataset.from_generator(
						        _lowerCamelCase			,   ({k: tf.intaa for k in input_names}, tf.intaa)			,   ({k: tf.TensorShape([None]     ) for k in input_names}, tf.TensorShape([]     ))			,   )
						    if datasets.Split.VALIDATION in transformed_ds
						    else None
						)

						if val_ds is not None:
												SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					val_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.VALIDATION]     )     )     )

						SCREAMING_SNAKE_CASE__     :				Dict   =					(
						    tf.data.Dataset.from_generator(
						        _lowerCamelCase			,   ({k: tf.intaa for k in input_names}, tf.intaa)			,   ({k: tf.TensorShape([None]     ) for k in input_names}, tf.TensorShape([]     ))			,   )
						    if datasets.Split.TEST in transformed_ds
						    else None
						)

						if test_ds is not None:
												SCREAMING_SNAKE_CASE__     :				Dict   =					test_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TEST]     )     )     )

						return train_ds, val_ds, test_ds, labelaid


__lowercase       :List[Any]       =  logging.getLogger(__name__)



@dataclass
class    _a     :






							"""simple docstring"""

							snake_case_							 =						field(metadata={"help": "Which column contains the label"}							)
							snake_case_							 =						field(default=lowercase__					,							metadata={"help": "The path of the training file"}							)
							snake_case_							 =						field(default=lowercase__					,							metadata={"help": "The path of the development file"}							)
							snake_case_							 =						field(default=lowercase__					,							metadata={"help": "The path of the test file"}							)
							snake_case_							 =						field(
							    default=1_28					,							metadata={
							        "help": (
							            "The maximum total input sequence length after tokenization. Sequences longer "
							            "than this will be truncated, sequences shorter will be padded."
							        )
							    }					,							)
							snake_case_							 =						field(
							    default=lowercase__					,							metadata={"help": "Overwrite the cached training and evaluation sets"}							)







@dataclass
class    _a     :






							"""simple docstring"""

							snake_case_							 =						field(
							    metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}							)
							snake_case_							 =						field(
							    default=lowercase__					,							metadata={"help": "Pretrained config name or path if not the same as model_name"}							)
							snake_case_							 =						field(
							    default=lowercase__					,							metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}							)
							snake_case_							 =						field(default=lowercase__					,							metadata={"help": "Set this flag to use fast tokenization."}							)
							# If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
							# or just modify its tokenizer_config.json.
							snake_case_							 =						field(
							    default=lowercase__					,							metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}					,							)







def       UpperCAmelCase							(     ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments)     )
						SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				List[Any]   =					parser.parse_args_into_dataclasses()

						if (
						    os.path.exists(training_args.output_dir     )
						    and os.listdir(training_args.output_dir     )
						    and training_args.do_train
						    and not training_args.overwrite_output_dir
						):
												raise ValueError(
												    f"""Output directory ({training_args.output_dir}) already exists and is not empty. Use"""
												    " --overwrite_output_dir to overcome."     )

						# Setup logging
						logging.basicConfig(
						    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"			,   datefmt="%m/%d/%Y %H:%M:%S"			,   level=logging.INFO			,   )
						logger.info(
						    f"""n_replicas: {training_args.n_replicas}, distributed training: {bool(training_args.n_replicas > 1     )}, """
						    f"""16-bits training: {training_args.fpaa}"""     )
						logger.info(f"""Training/evaluation parameters {training_args}"""     )

						# Load pretrained model and tokenizer
						#
						# Distributed training:
						# The .from_pretrained methods guarantee that only one local process can concurrently
						# download model & vocab.

						SCREAMING_SNAKE_CASE__     :				Any   =					AutoTokenizer.from_pretrained(
						    model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path			,   cache_dir=model_args.cache_dir			,   )

						SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					get_tfds(
						    train_file=data_args.train_file			,   eval_file=data_args.dev_file			,   test_file=data_args.test_file			,   tokenizer=_lowerCamelCase			,   label_column_id=data_args.label_column_id			,   max_seq_length=data_args.max_seq_length			,   )

						SCREAMING_SNAKE_CASE__     :				str   =					AutoConfig.from_pretrained(
						    model_args.config_name if model_args.config_name else model_args.model_name_or_path			,   num_labels=len(_lowerCamelCase     )			,   labelaid=_lowerCamelCase			,   idalabel={id: label for label, id in labelaid.items()}			,   finetuning_task="text-classification"			,   cache_dir=model_args.cache_dir			,   )

						with training_args.strategy.scope():
												SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					TFAutoModelForSequenceClassification.from_pretrained(
												    model_args.model_name_or_path			,   from_pt=bool(".bin" in model_args.model_name_or_path     )			,   config=_lowerCamelCase			,   cache_dir=model_args.cache_dir			,   )

						def compute_metrics(_lowerCamelCase      :  EvalPrediction     ) -> Dict:
												SCREAMING_SNAKE_CASE__     :				Dict   =					np.argmax(p.predictions			,   axis=1     )

												return {"acc": (preds == p.label_ids).mean()}

						# Initialize our Trainer
						SCREAMING_SNAKE_CASE__     :				str   =					TFTrainer(
						    model=_lowerCamelCase			,   args=_lowerCamelCase			,   train_dataset=_lowerCamelCase			,   eval_dataset=_lowerCamelCase			,   compute_metrics=_lowerCamelCase			,   )

						# Training
						if training_args.do_train:
												trainer.train()
												trainer.save_model()
												tokenizer.save_pretrained(training_args.output_dir     )

						# Evaluation
						SCREAMING_SNAKE_CASE__     :				Dict   =					{}
						if training_args.do_eval:
												logger.info("*** Evaluate ***"     )
												SCREAMING_SNAKE_CASE__     :				str   =					trainer.evaluate()
												SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					os.path.join(training_args.output_dir			,   "eval_results.txt"     )

												with open(_lowerCamelCase			,   "w"     ) as writer:
																		logger.info("***** Eval results *****"     )

																		for key, value in result.items():
																								logger.info(f"""  {key} = {value}"""     )
																								writer.write(f"""{key} = {value}\n"""     )

																		results.update(_lowerCamelCase     )

						return results


if __name__ == "__main__":
				main()