





import argparse
import glob
import inspect
import os
import re
import unittest

from get_test_info import get_test_classes

from tests.test_pipeline_mixin import pipeline_test_mapping


_lowercase		:     List[str] 					={}
for task, _ in pipeline_test_mapping.items():
		_lowercase		:     Optional[int] 					={"""pt""": None, """tf""": None}


# DO **NOT** add item to this set (unless the reason is approved)
_lowercase		:     List[str] 					={
    """tests/models/esm/test_modeling_esmfold.py""",  # The pipeline test mapping is added to `test_modeling_esm.py`
}


def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):

		if "ModelTesterMixin" in [x.__name__ for x in test_class.__bases__]:
				return "pt"
		elif "TFModelTesterMixin" in [x.__name__ for x in test_class.__bases__]:
				return "tf"
		elif "FlaxModelTesterMixin" in [x.__name__ for x in test_class.__bases__]:
				return "flax"
		else:
				return None


def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
		# Use the cached results
		if PIPELINE_TEST_MAPPING[task].get(lowerCAmelCase__       ,lowerCAmelCase__	) is not None:
				return PIPELINE_TEST_MAPPING[task][framework]

		lowerCamelCase_  :    Tuple   	=			pipeline_test_mapping[task]['test']
		lowerCamelCase_  :    Optional[int]   	=			None

		if framework == "pt":
				lowerCamelCase_  :    Tuple   	=			getattr(lowerCAmelCase__       ,'model_mapping'       ,lowerCAmelCase__	)
		elif framework == "tf":
				lowerCamelCase_  :    List[Any]   	=			getattr(lowerCAmelCase__       ,'tf_model_mapping'       ,lowerCAmelCase__	)

		if mapping is not None:
				lowerCamelCase_  :    Any   	=			dict(mapping.items()	)

		# cache the results
		lowerCamelCase_  :    Tuple   	=			mapping
		return mapping


def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
		lowerCamelCase_  :    str   	=			get_framework(lowerCAmelCase__	)
		if framework is None:
				return None
		lowerCamelCase_  :    str   	=			get_mapping_for_task(lowerCAmelCase__       ,lowerCAmelCase__	)
		if mapping is None:
				return None

		lowerCamelCase_  :    int   	=			list({model_class.config_class for model_class in test_class.all_model_classes}	)
		if len(lowerCAmelCase__	) != 1:
				raise ValueError('There should be exactly one configuration class from `test_class.all_model_classes`.'	)

		# This could be a list/tuple of model classes, but it's rare.
		lowerCamelCase_  :    int   	=			mapping.get(config_classes[0]       ,lowerCAmelCase__	)
		if isinstance(lowerCAmelCase__       ,(tuple, list)	):
				lowerCamelCase_  :    Tuple   	=			sorted(lowerCAmelCase__       ,key=lambda lowerCAmelCase__	: x.__name__	)

		return model_class


def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):
		lowerCamelCase_  :    Tuple   	=			[(task, get_model_for_pipeline_test(lowerCAmelCase__       ,lowerCAmelCase__	)) for task in pipeline_test_mapping]
		lowerCamelCase_  :    int   	=			sorted([(task, model) for task, model in mapping if model is not None]       ,key=lambda lowerCAmelCase__	: x[0]	)

		return dict(lowerCAmelCase__	)


def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):
		lowerCamelCase_  :    str   	=			get_framework(lowerCAmelCase__	)
		if framework == "pt":
				lowerCamelCase_  :    str   	=			'torch'
		lowerCamelCase_  :    Any   	=			'{}'

		lowerCamelCase_  :    Optional[int]   	=			get_pipeline_model_mapping(lowerCAmelCase__	)
		if len(lowerCAmelCase__	) == 0:
				return ""

		lowerCamelCase_  :    Optional[int]   	=			[]
		for task, model_classes in mapping.items():
				if isinstance(lowerCAmelCase__       ,(tuple, list)	):
						# A list/tuple of model classes
						lowerCamelCase_  :    Tuple   	=			'(' + ', '.join([x.__name__ for x in model_classes]	) + ')'
				else:
						# A single model class
						lowerCamelCase_  :    List[str]   	=			model_classes.__name__
				texts.append(F"\"{task}\": {value}"	)
		lowerCamelCase_  :    str   	=			'{' + ', '.join(lowerCAmelCase__	) + '}'
		lowerCamelCase_  :    Union[str, Any]   	=			F"pipeline_model_mapping = {text} if is_{framework}_available() else {default_value}"

		return text


def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):
		lowerCamelCase_  :    Optional[int]   	=			{'ModelTesterMixin', 'TFModelTesterMixin', 'FlaxModelTesterMixin'}
		if not issubclass(lowerCAmelCase__       ,unittest.TestCase	):
				return False
		return len(base_class_names.intersection([x.__name__ for x in test_class.__bases__]	)	) > 0


def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):
		lowerCamelCase_  :    Tuple   	=			[x for x in get_test_classes(lowerCAmelCase__	) if is_valid_test_class(lowerCAmelCase__	)]

		lowerCamelCase_  :    str   	=			None
		for test_class in test_classes:
				# If a test class has defined `pipeline_model_mapping`, let's take it
				if getattr(lowerCAmelCase__       ,'pipeline_model_mapping'       ,lowerCAmelCase__	) is not None:
						lowerCamelCase_  :    str   	=			test_class
						break
    # Take the test class with the shortest name (just a heuristic)
		if target_test_class is None and len(lowerCAmelCase__	) > 0:
				lowerCamelCase_  :    Dict   	=			sorted(lowerCAmelCase__       ,key=lambda lowerCAmelCase__	: (len(x.__name__	), x.__name__)	)[0]

		return target_test_class


def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__	):
		lowerCamelCase_  :    List[Any]   	=			start_idx
		for idx, line in enumerate(lines[start_idx:]	):
				lowerCamelCase_  :    Tuple   	=			len(lowerCAmelCase__	) - len(line.lstrip()	)
				if idx == 0 or indent > indent_level or (indent == indent_level and line.strip() == ")"):
						lowerCamelCase_  :    Optional[int]   	=			start_idx + idx
				elif idx > 0 and indent <= indent_level:
						# Outside the definition block of `pipeline_model_mapping`
						break

		return end_idx


def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__=False	):
		if getattr(lowerCAmelCase__       ,'pipeline_model_mapping'       ,lowerCAmelCase__	) is not None:
				if not overwrite:
						return "", -1

		lowerCamelCase_  :    List[str]   	=			get_pipeline_model_mapping_string(lowerCAmelCase__	)
		if len(lowerCAmelCase__	) == 0:
				return "", -1
		lowerCamelCase_  :    List[str]   	=			line_to_add + '\n'

		# The code defined the class `test_class`
		lowerCamelCase_  :    List[str]   	=			inspect.getsourcelines(lowerCAmelCase__	)
		# `inspect` gives the code for an object, including decorator(s) if any.
		# We (only) need the exact line of the class definition.
		for idx, line in enumerate(lowerCAmelCase__	):
				if line.lstrip().startswith('class '	):
						lowerCamelCase_  :    Optional[Any]   	=			class_lines[idx:]
						class_start_line_no += idx
						break
		lowerCamelCase_  :    Any   	=			class_start_line_no + len(lowerCAmelCase__	) - 1

		# The index in `class_lines` that starts the definition of `all_model_classes`, `all_generative_model_classes` or
		# `pipeline_model_mapping`. This assumes they are defined in such order, and we take the start index of the last
		# block that appears in a `test_class`.
		lowerCamelCase_  :    str   	=			None
		# The indent level of the line at `class_lines[start_idx]` (if defined)
		lowerCamelCase_  :    Tuple   	=			0
		# To record if `pipeline_model_mapping` is found in `test_class`.
		lowerCamelCase_  :    Optional[Any]   	=			None
		for idx, line in enumerate(lowerCAmelCase__	):
				if line.strip().startswith('all_model_classes = '	):
						lowerCamelCase_  :    Optional[int]   	=			len(lowerCAmelCase__	) - len(line.lstrip()	)
						lowerCamelCase_  :    Tuple   	=			idx
				elif line.strip().startswith('all_generative_model_classes = '	):
						lowerCamelCase_  :    Tuple   	=			len(lowerCAmelCase__	) - len(line.lstrip()	)
						lowerCamelCase_  :    Dict   	=			idx
				elif line.strip().startswith('pipeline_model_mapping = '	):
						lowerCamelCase_  :    Optional[Any]   	=			len(lowerCAmelCase__	) - len(line.lstrip()	)
						lowerCamelCase_  :    Union[str, Any]   	=			idx
						lowerCamelCase_  :    List[str]   	=			line
						break

		if start_idx is None:
				return "", -1
		# Find the ending index (inclusive) of the above found block.
		lowerCamelCase_  :    Optional[int]   	=			find_block_ending(lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__	)

		# Extract `is_xxx_available()` from existing blocks: some models require specific libraries like `timm` and use
		# `is_timm_available()` instead of `is_torch_available()`.
		# Keep leading and trailing whitespaces
		lowerCamelCase_  :    Any   	=			re.compile(r'\s(is_\S+?_available\(\))\s'	)
		for line in class_lines[start_idx : end_idx + 1]:
				lowerCamelCase_  :    List[str]   	=			r.search(lowerCAmelCase__	)
				if backend_condition is not None:
						# replace the leading and trailing whitespaces to the space character " ".
						lowerCamelCase_  :    str   	=			' ' + backend_condition[0][1:-1] + ' '
						lowerCamelCase_  :    int   	=			r.sub(lowerCAmelCase__       ,lowerCAmelCase__	)
						break

		if def_line is None:
				# `pipeline_model_mapping` is not defined. The target index is set to the ending index (inclusive) of
				# `all_model_classes` or `all_generative_model_classes`.
				lowerCamelCase_  :    List[str]   	=			end_idx
		else:
				# `pipeline_model_mapping` is defined. The target index is set to be one **BEFORE** its start index.
				lowerCamelCase_  :    Tuple   	=			start_idx - 1
				# mark the lines of the currently existing `pipeline_model_mapping` to be removed.
				for idx in range(lowerCAmelCase__       ,end_idx + 1	):
						# These lines are going to be removed before writing to the test file.
						lowerCamelCase_  :    List[Any]   	=			None  # noqa

    # Make sure the test class is a subclass of `PipelineTesterMixin`.
		lowerCamelCase_  :    List[Any]   	=			[x.__name__ for x in test_class.__bases__]
		if "PipelineTesterMixin" not in parent_classes:
				# Put `PipelineTesterMixin` just before `unittest.TestCase`
				lowerCamelCase_  :    List[Any]   	=			[x for x in parent_classes if x != 'TestCase'] + ['PipelineTesterMixin']
				if "TestCase" in parent_classes:
						# Here we **assume** the original string is always with `unittest.TestCase`.
						_parent_classes.append('unittest.TestCase'	)
				lowerCamelCase_  :    Dict   	=			', '.join(_parent_classes	)
				for idx, line in enumerate(lowerCAmelCase__	):
						# Find the ending of the declaration of `test_class`
						if line.strip().endswith('):'	):
								# mark the lines of the declaration of `test_class` to be removed
								for _idx in range(idx + 1	):
										lowerCamelCase_  :    Dict   	=			None  # noqa
								break
        # Add the new, one-line, class declaration for `test_class`
				lowerCamelCase_  :    List[Any]   	=			F"class {test_class.__name__}({parent_classes}):\n"

		# Add indentation
		lowerCamelCase_  :    str   	=			' ' * indent_level + line_to_add
		# Insert `pipeline_model_mapping` to `class_lines`.
		# (The line at `target_idx` should be kept by definition!)
		lowerCamelCase_  :    Optional[Any]   	=			class_lines[: target_idx + 1] + [line_to_add] + class_lines[target_idx + 1 :]
		# Remove the lines that are marked to be removed
		lowerCamelCase_  :    List[Any]   	=			[x for x in class_lines if x is not None]

		# Move from test class to module (in order to write to the test file)
		lowerCamelCase_  :    str   	=			inspect.getsourcelines(inspect.getmodule(lowerCAmelCase__	)	)[0]
		# Be careful with the 1-off between line numbers and array indices
		lowerCamelCase_  :    List[Any]   	=			module_lines[: class_start_line_no - 1] + class_lines + module_lines[class_end_line_no:]
		lowerCamelCase_  :    str   	=			''.join(lowerCAmelCase__	)

		lowerCamelCase_  :    List[str]   	=			inspect.getsourcefile(lowerCAmelCase__	)
		with open(lowerCAmelCase__       ,'w'       ,encoding='UTF-8'       ,newline='\n'	) as fp:
				fp.write(lowerCAmelCase__	)

		return line_to_add


def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__=False	):
		lowerCamelCase_  :    Tuple   	=			find_test_class(lowerCAmelCase__	)
		if test_class:
				add_pipeline_model_mapping(lowerCAmelCase__       ,overwrite=lowerCAmelCase__	)


if __name__ == "__main__":
		_lowercase		:     Union[str, Any] 					=argparse.ArgumentParser()
		parser.add_argument(
		    """--test_file""", type=str, help="""A path to the test file, starting with the repository's `tests` directory."""
		)
		parser.add_argument(
		    """--all""",
		    action="""store_true""",
		    help="""If to check and modify all test files.""",
		)
		parser.add_argument(
		    """--overwrite""",
		    action="""store_true""",
		    help="""If to overwrite a test class if it has already defined `pipeline_model_mapping`.""",
		)
		_lowercase		:     Dict 					=parser.parse_args()

		if not args.all and not args.test_file:
				raise ValueError("""Please specify either `test_file` or pass `--all` to check/modify all test files.""")
		elif args.all and args.test_file:
				raise ValueError("""Only one of `--test_file` and `--all` could be specified.""")

		_lowercase		:     List[str] 					=[]
		if args.test_file:
				_lowercase		:     Any 					=[args.test_file]
		else:
				_lowercase		:     Optional[int] 					=os.path.join("""tests""", """models""", """**""", """test_modeling_*.py""")
				for test_file in glob.glob(pattern):
						# `Flax` is not concerned at this moment
						if not test_file.startswith("""test_modeling_flax_"""):
								test_files.append(test_file)

		for test_file in test_files:
				if test_file in TEST_FILE_TO_IGNORE:
						print(F'''[SKIPPED] {test_file} is skipped as it is in `TEST_FILE_TO_IGNORE` in the file {__file__}.''')
						continue
				add_pipeline_model_mapping_to_test_file(test_file, overwrite=args.overwrite)







import gc
import unittest

import numpy as np
import torch

from diffusers import DDPMScheduler, MidiProcessor, SpectrogramDiffusionPipeline
from diffusers.pipelines.spectrogram_diffusion import SpectrogramContEncoder, SpectrogramNotesEncoder, TaFilmDecoder
from diffusers.utils import require_torch_gpu, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_note_seq, require_onnxruntime

from ..pipeline_params import TOKENS_TO_AUDIO_GENERATION_BATCH_PARAMS, TOKENS_TO_AUDIO_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


_lowercase		:     Optional[Any] 					="""./tests/fixtures/elise_format0.mid"""






@unittest.skip('The note-seq package currently throws an error on import'       )
class 	UpperCamelCase_     (     snake_case__     ,    unittest.TestCase       ):
					_a			:	int							=				SpectrogramDiffusionPipeline
					_a			:	Dict							=				PipelineTesterMixin.required_optional_params - {
					    'callback',
					    'latents',
					    'callback_steps',
					    'output_type',
					    'num_images_per_prompt',
					}
					_a			:	str							=				False
					_a			:	Union[str, Any]							=				False
					_a			:	Optional[int]							=				TOKENS_TO_AUDIO_GENERATION_PARAMS
					_a			:	Optional[Any]							=				TOKENS_TO_AUDIO_GENERATION_BATCH_PARAMS



					def      __a    (		self    :    Dict	):
							torch.manual_seed(0	)
							lowerCamelCase_  :    List[str]   	=			SpectrogramNotesEncoder(
							    max_length=20_48					,			vocab_size=15_36					,			d_model=7_68					,			dropout_rate=0.1					,			num_layers=1					,			num_heads=1					,			d_kv=4					,			d_ff=20_48					,			feed_forward_proj='gated-gelu'					,			)

							lowerCamelCase_  :    Union[str, Any]   	=			SpectrogramContEncoder(
							    input_dims=1_28					,			targets_context_length=2_56					,			d_model=7_68					,			dropout_rate=0.1					,			num_layers=1					,			num_heads=1					,			d_kv=4					,			d_ff=20_48					,			feed_forward_proj='gated-gelu'					,			)

							lowerCamelCase_  :    Union[str, Any]   	=			TaFilmDecoder(
							    input_dims=1_28					,			targets_length=2_56					,			max_decoder_noise_time=20_000.0					,			d_model=7_68					,			num_layers=1					,			num_heads=1					,			d_kv=4					,			d_ff=20_48					,			dropout_rate=0.1					,			)

							lowerCamelCase_  :    Any   	=			DDPMScheduler()

							lowerCamelCase_  :    str   	=			{
							    'notes_encoder': notes_encoder.eval(),
							    'continuous_encoder': continuous_encoder.eval(),
							    'decoder': decoder.eval(),
							    'scheduler': scheduler,
							    'melgan': None,
							}
							return components



					def      __a    (		self    :    Any					,			lowerCamelCase    :    Any					,			lowerCamelCase    :    int=0	):
							if str(lowerCamelCase	).startswith('mps'	):
									lowerCamelCase_  :    Optional[int]   	=			torch.manual_seed(lowerCamelCase	)
							else:
									lowerCamelCase_  :    Dict   	=			torch.Generator(device=lowerCamelCase	).manual_seed(lowerCamelCase	)
							lowerCamelCase_  :    str   	=			{
							    'input_tokens': [
							        [11_34, 90, 11_35, 11_33, 10_80, 1_12, 11_32, 10_80, 11_33, 10_79, 1_33, 11_32, 10_79, 11_33, 1] + [0] * 20_33
							    ],
							    'generator': generator,
							    'num_inference_steps': 4,
							    'output_type': 'mel',
							}
							return inputs



					def      __a    (		self    :    Dict	):
							lowerCamelCase_  :    str   	=			'cpu'  # ensure determinism for the device-dependent torch.Generator
							lowerCamelCase_  :    Dict   	=			self.get_dummy_components()
							lowerCamelCase_  :    Tuple   	=			SpectrogramDiffusionPipeline(**lowerCamelCase	)
							lowerCamelCase_  :    List[str]   	=			pipe.to(lowerCamelCase	)
							pipe.set_progress_bar_config(disable=lowerCamelCase	)

							lowerCamelCase_  :    Optional[Any]   	=			self.get_dummy_inputs(lowerCamelCase	)
							lowerCamelCase_  :    str   	=			pipe(**lowerCamelCase	)
							lowerCamelCase_  :    Tuple   	=			output.audios

							lowerCamelCase_  :    Tuple   	=			mel[0, -3:, -3:]

							assert mel_slice.shape == (3, 3)
							lowerCamelCase_  :    List[str]   	=			np.array(
							    [-11.512_925, -4.788_215, -0.46_172_905, -2.051_715, -10.539_147, -10.970_963, -9.091_634, 4.0, 4.0]	)
							assert np.abs(mel_slice.flatten() - expected_slice	).max() < 1E-2



					@skip_mps
					def      __a    (		self    :    Any	):
							return super().test_save_load_local()



					@skip_mps
					def      __a    (		self    :    Tuple	):
							return super().test_dict_tuple_outputs_equivalent()



					@skip_mps
					def      __a    (		self    :    Dict	):
							return super().test_save_load_optional_components()



					@skip_mps
					def      __a    (		self    :    str	):
							return super().test_attention_slicing_forward_pass()



					def      __a    (		self    :    Any	):
							pass



					def      __a    (		self    :    Optional[int]	):
							pass





					@skip_mps
					def      __a    (		self    :    Optional[Any]	):
							return super().test_progress_bar()






@slow
@require_torch_gpu
@require_onnxruntime
@require_note_seq
class 	UpperCamelCase_     (     unittest.TestCase       ):



					def      __a    (		self    :    Optional[int]	):
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()



					def      __a    (		self    :    str	):
							# TODO - test that pipeline can decode tokens in a callback
							# so that music can be played live
							lowerCamelCase_  :    Optional[Any]   	=			torch_device

							lowerCamelCase_  :    Union[str, Any]   	=			SpectrogramDiffusionPipeline.from_pretrained('google/music-spectrogram-diffusion'	)
							lowerCamelCase_  :    str   	=			pipe.melgan
							lowerCamelCase_  :    Optional[int]   	=			None

							lowerCamelCase_  :    str   	=			pipe.to(lowerCamelCase	)
							pipe.set_progress_bar_config(disable=lowerCamelCase	)

							def callback(lowerCamelCase    :    int					,			lowerCamelCase    :    int	):
									# decode mel to audio
									lowerCamelCase_  :    Union[str, Any]   	=			melgan(input_features=mel_output.astype(np.floataa	)	)[0]
									assert len(audio[0]	) == 8_19_20 * (step + 1)
									# simulate that audio is played
									return audio

							lowerCamelCase_  :    Any   	=			MidiProcessor()
							lowerCamelCase_  :    str   	=			processor(lowerCamelCase	)

							lowerCamelCase_  :    str   	=			input_tokens[:3]
							lowerCamelCase_  :    Dict   	=			torch.manual_seed(0	)
							pipe(lowerCamelCase					,			num_inference_steps=5					,			generator=lowerCamelCase					,			callback=lowerCamelCase					,			output_type='mel'	)



					def      __a    (		self    :    str	):
							lowerCamelCase_  :    List[str]   	=			torch_device

							lowerCamelCase_  :    List[str]   	=			SpectrogramDiffusionPipeline.from_pretrained('google/music-spectrogram-diffusion'	)
							lowerCamelCase_  :    Union[str, Any]   	=			pipe.to(lowerCamelCase	)
							pipe.set_progress_bar_config(disable=lowerCamelCase	)
							lowerCamelCase_  :    int   	=			MidiProcessor()

							lowerCamelCase_  :    Dict   	=			processor(lowerCamelCase	)
							# just run two denoising loops
							lowerCamelCase_  :    Optional[Any]   	=			input_tokens[:2]

							lowerCamelCase_  :    List[Any]   	=			torch.manual_seed(0	)
							lowerCamelCase_  :    str   	=			pipe(lowerCamelCase					,			num_inference_steps=2					,			generator=lowerCamelCase	)

							lowerCamelCase_  :    Dict   	=			output.audios[0]

							assert abs(np.abs(lowerCamelCase	).sum() - 3_612.841	) < 1E-1





					def      __a    (		self    :    List[Any]	):
							lowerCamelCase_  :    int   	=			torch_device

							lowerCamelCase_  :    str   	=			SpectrogramDiffusionPipeline.from_pretrained('google/music-spectrogram-diffusion'	)
							lowerCamelCase_  :    Optional[int]   	=			pipe.to(lowerCamelCase	)
							pipe.set_progress_bar_config(disable=lowerCamelCase	)

							lowerCamelCase_  :    Tuple   	=			MidiProcessor()

							lowerCamelCase_  :    int   	=			processor(lowerCamelCase	)

							# just run 4 denoising loops
							lowerCamelCase_  :    Optional[Any]   	=			input_tokens[:4]

							lowerCamelCase_  :    List[Any]   	=			torch.manual_seed(0	)
							lowerCamelCase_  :    int   	=			pipe(lowerCamelCase					,			num_inference_steps=1_00					,			generator=lowerCamelCase	)

							lowerCamelCase_  :    List[Any]   	=			output.audios[0]
							assert abs(np.abs(lowerCamelCase	).sum() - 9_389.1_111	) < 5E-2
