"""simple docstring"""






import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
						import torch


lowerCAmelCase__						:						Any		  =			random.Random()



def 						a_		(      lowerCamelCase      ,    lowerCamelCase=1.0      ,    lowerCamelCase=None      ,    lowerCamelCase=None ):
				if rng is None:
								UpperCAmelCase__    =							global_rng

				UpperCAmelCase__    =							[]
				for batch_idx in range(shape[0] ):
								values.append([] )
								for _ in range(shape[1] ):
												values[-1].append(rng.random() * scale )

				return values
@require_torch
class        snake_case (				unittest.TestCase       ):




					"""simple docstring"""

					def __init__(       self     :			str					,lowerCamelCase__     :			Optional[Any]					,lowerCamelCase__     :			Dict=7					,lowerCamelCase__     :			Optional[int]=400					,lowerCamelCase__     :			List[str]=2_000					,lowerCamelCase__     :			Any=1					,lowerCamelCase__     :			Any=0.0					,lowerCamelCase__     :			str=16_000					,lowerCamelCase__     :			str=True					,lowerCamelCase__     :			Union[str, Any]=80					,lowerCamelCase__     :			List[Any]=16					,lowerCamelCase__     :			List[str]=64					,lowerCamelCase__     :			Union[str, Any]="hann_window"					,lowerCamelCase__     :			Optional[Any]=80					,lowerCamelCase__     :			Dict=7_600					,lowerCamelCase__     :			List[Any]=1e-10					,lowerCamelCase__     :			Union[str, Any]=True					,):
									UpperCAmelCase__    =							parent
									UpperCAmelCase__    =							batch_size
									UpperCAmelCase__    =							min_seq_length
									UpperCAmelCase__    =							max_seq_length
									UpperCAmelCase__    =							(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
									UpperCAmelCase__    =							feature_size
									UpperCAmelCase__    =							padding_value
									UpperCAmelCase__    =							sampling_rate
									UpperCAmelCase__    =							do_normalize
									UpperCAmelCase__    =							num_mel_bins
									UpperCAmelCase__    =							hop_length
									UpperCAmelCase__    =							win_length
									UpperCAmelCase__    =							win_function
									UpperCAmelCase__    =							fmin
									UpperCAmelCase__    =							fmax
									UpperCAmelCase__    =							mel_floor
									UpperCAmelCase__    =							return_attention_mask







					def 	__lowerCAmelCase		(       self     :			Tuple    ):
									return {
									    "feature_size": self.feature_size,
									    "padding_value": self.padding_value,
									    "sampling_rate": self.sampling_rate,
									    "do_normalize": self.do_normalize,
									    "num_mel_bins": self.num_mel_bins,
									    "hop_length": self.hop_length,
									    "win_length": self.win_length,
									    "win_function": self.win_function,
									    "fmin": self.fmin,
									    "fmax": self.fmax,
									    "mel_floor": self.mel_floor,
									    "return_attention_mask": self.return_attention_mask,
									}







					def 	__lowerCAmelCase		(       self     :			List[Any]					,lowerCamelCase__     :			List[str]=False					,lowerCamelCase__     :			Tuple=False    ):
									def _flatten(lowerCamelCase__     :			List[Any]    ):
													return list(itertools.chain(*lowerCamelCase__    )    )

									if equal_length:
													UpperCAmelCase__    =							floats_list((self.batch_size, self.max_seq_length)    )
									else:
													# make sure that inputs increase in size
													UpperCAmelCase__    =							[
													    _flatten(floats_list((x, self.feature_size)    )    )
													    for x in range(self.min_seq_length					,self.max_seq_length					,self.seq_length_diff    )
													]

									if numpify:
													UpperCAmelCase__    =							[np.asarray(lowerCamelCase__    ) for x in speech_inputs]

									return speech_inputs







					def 	__lowerCAmelCase		(       self     :			List[Any]					,lowerCamelCase__     :			Union[str, Any]=False					,lowerCamelCase__     :			Optional[Any]=False    ):
									if equal_length:
													UpperCAmelCase__    =							[floats_list((self.max_seq_length, self.num_mel_bins)    ) for _ in range(self.batch_size    )]
									else:
													# make sure that inputs increase in size
													UpperCAmelCase__    =							[
													    floats_list((x, self.num_mel_bins)    )
													    for x in range(self.min_seq_length					,self.max_seq_length					,self.seq_length_diff    )
													]

									if numpify:
													UpperCAmelCase__    =							[np.asarray(lowerCamelCase__    ) for x in speech_inputs]

									return speech_inputs






@require_torch
class        snake_case (				__UpperCAmelCase   ,					unittest.TestCase       ):




					"""simple docstring"""

					snake_case__       					=				SpeechTaFeatureExtractor







					def 	__lowerCAmelCase		(       self     :			Any    ):
									UpperCAmelCase__    =							SpeechTaFeatureExtractionTester(self    )







					def 	__lowerCAmelCase		(       self     :			Any					,lowerCamelCase__     :			Optional[Any]    ):
									self.assertTrue(np.all(np.mean(lowerCamelCase__					,axis=0    ) < 1e-3    )    )
									self.assertTrue(np.all(np.abs(np.var(lowerCamelCase__					,axis=0    ) - 1    ) < 1e-3    )    )







					def 	__lowerCAmelCase		(       self     :			Any    ):
									# Tests that all call wrap to encode_plus and batch_encode_plus
									UpperCAmelCase__    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									# create three inputs of length 800, 1000, and 1200
									UpperCAmelCase__    =							[floats_list((1, x)    )[0] for x in range(800					,1_400					,200    )]
									UpperCAmelCase__    =							[np.asarray(lowerCamelCase__    ) for speech_input in speech_inputs]

									# Test not batched input
									UpperCAmelCase__    =							feat_extract(speech_inputs[0]					,return_tensors='np'    ).input_values
									UpperCAmelCase__    =							feat_extract(np_speech_inputs[0]					,return_tensors='np'    ).input_values
									self.assertTrue(np.allclose(lowerCamelCase__					,lowerCamelCase__					,atol=1e-3    )    )

									# Test batched
									UpperCAmelCase__    =							feat_extract(lowerCamelCase__					,return_tensors='np'    ).input_values
									UpperCAmelCase__    =							feat_extract(lowerCamelCase__					,return_tensors='np'    ).input_values
									for enc_seq_a, enc_seq_a in zip(lowerCamelCase__					,lowerCamelCase__    ):
													self.assertTrue(np.allclose(lowerCamelCase__					,lowerCamelCase__					,atol=1e-3    )    )







					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									UpperCAmelCase__    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									UpperCAmelCase__    =							[floats_list((1, x)    )[0] for x in range(800					,1_400					,200    )]

									UpperCAmelCase__    =							['longest', 'max_length', 'do_not_pad']
									UpperCAmelCase__    =							[None, 1_600, None]
									for max_length, padding in zip(lowerCamelCase__					,lowerCamelCase__    ):
													UpperCAmelCase__    =							feat_extract(lowerCamelCase__					,padding=lowerCamelCase__					,max_length=lowerCamelCase__					,return_tensors='np'    )
													UpperCAmelCase__    =							processed.input_values

													self._check_zero_mean_unit_variance(input_values[0][:800]    )
													self.assertTrue(input_values[0][800:].sum() < 1e-6    )
													self._check_zero_mean_unit_variance(input_values[1][:1_000]    )
													self.assertTrue(input_values[0][1_000:].sum() < 1e-6    )
													self._check_zero_mean_unit_variance(input_values[2][:1_200]    )







					def 	__lowerCAmelCase		(       self     :			str    ):
									UpperCAmelCase__    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									UpperCAmelCase__    =							range(800					,1_400					,200    )
									UpperCAmelCase__    =							[floats_list((1, x)    )[0] for x in lengths]

									UpperCAmelCase__    =							['longest', 'max_length', 'do_not_pad']
									UpperCAmelCase__    =							[None, 1_600, None]

									for max_length, padding in zip(lowerCamelCase__					,lowerCamelCase__    ):
													UpperCAmelCase__    =							feat_extract(lowerCamelCase__					,max_length=lowerCamelCase__					,padding=lowerCamelCase__    )
													UpperCAmelCase__    =							processed.input_values

													self._check_zero_mean_unit_variance(input_values[0][:800]    )
													self._check_zero_mean_unit_variance(input_values[1][:1_000]    )
													self._check_zero_mean_unit_variance(input_values[2][:1_200]    )







					def 	__lowerCAmelCase		(       self     :			int    ):
									UpperCAmelCase__    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									UpperCAmelCase__    =							[floats_list((1, x)    )[0] for x in range(800					,1_400					,200    )]
									UpperCAmelCase__    =							feat_extract(
									    lowerCamelCase__					,truncation=lowerCamelCase__					,max_length=1_000					,padding='max_length'					,return_tensors='np'    )
									UpperCAmelCase__    =							processed.input_values

									self._check_zero_mean_unit_variance(input_values[0, :800]    )
									self._check_zero_mean_unit_variance(input_values[1]    )
									self._check_zero_mean_unit_variance(input_values[2]    )







					def 	__lowerCAmelCase		(       self     :			Dict    ):
									UpperCAmelCase__    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									UpperCAmelCase__    =							[floats_list((1, x)    )[0] for x in range(800					,1_400					,200    )]
									UpperCAmelCase__    =							feat_extract(
									    lowerCamelCase__					,truncation=lowerCamelCase__					,max_length=1_000					,padding='longest'					,return_tensors='np'    )
									UpperCAmelCase__    =							processed.input_values

									self._check_zero_mean_unit_variance(input_values[0, :800]    )
									self._check_zero_mean_unit_variance(input_values[1, :1_000]    )
									self._check_zero_mean_unit_variance(input_values[2]    )

									# make sure that if max_length < longest -> then pad to max_length
									self.assertTrue(input_values.shape == (3, 1_000)    )

									UpperCAmelCase__    =							[floats_list((1, x)    )[0] for x in range(800					,1_400					,200    )]
									UpperCAmelCase__    =							feat_extract(
									    lowerCamelCase__					,truncation=lowerCamelCase__					,max_length=2_000					,padding='longest'					,return_tensors='np'    )
									UpperCAmelCase__    =							processed.input_values

									self._check_zero_mean_unit_variance(input_values[0, :800]    )
									self._check_zero_mean_unit_variance(input_values[1, :1_000]    )
									self._check_zero_mean_unit_variance(input_values[2]    )

									# make sure that if max_length > longest -> then pad to longest
									self.assertTrue(input_values.shape == (3, 1_200)    )







					def 	__lowerCAmelCase		(       self     :			int    ):
									UpperCAmelCase__    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									UpperCAmelCase__    =							np.random.rand(100    ).astype(np.floataa    )
									UpperCAmelCase__    =							np_speech_inputs.tolist()

									for inputs in [py_speech_inputs, np_speech_inputs]:
													UpperCAmelCase__    =							feature_extractor.pad([{'input_values': inputs}]					,return_tensors='np'    )
													self.assertTrue(np_processed.input_values.dtype == np.floataa    )
													UpperCAmelCase__    =							feature_extractor.pad([{'input_values': inputs}]					,return_tensors='pt'    )
													self.assertTrue(pt_processed.input_values.dtype == torch.floataa    )







					def 	__lowerCAmelCase		(       self     :			str    ):
									# Tests that all call wrap to encode_plus and batch_encode_plus
									UpperCAmelCase__    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									# create three inputs of length 800, 1000, and 1200
									UpperCAmelCase__    =							[floats_list((1, x)    )[0] for x in range(800					,1_400					,200    )]
									UpperCAmelCase__    =							[np.asarray(lowerCamelCase__    ) for speech_input in speech_inputs]

									# Test feature size
									UpperCAmelCase__    =							feature_extractor(audio_target=lowerCamelCase__					,padding=lowerCamelCase__					,return_tensors='np'    ).input_values
									self.assertTrue(input_values.ndim == 3    )
									self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins    )

									# Test not batched input
									UpperCAmelCase__    =							feature_extractor(speech_inputs[0]					,return_tensors='np'    ).input_values
									UpperCAmelCase__    =							feature_extractor(np_speech_inputs[0]					,return_tensors='np'    ).input_values
									self.assertTrue(np.allclose(lowerCamelCase__					,lowerCamelCase__					,atol=1e-3    )    )

									# Test batched
									UpperCAmelCase__    =							feature_extractor(lowerCamelCase__					,return_tensors='np'    ).input_values
									UpperCAmelCase__    =							feature_extractor(lowerCamelCase__					,return_tensors='np'    ).input_values
									for enc_seq_a, enc_seq_a in zip(lowerCamelCase__					,lowerCamelCase__    ):
													self.assertTrue(np.allclose(lowerCamelCase__					,lowerCamelCase__					,atol=1e-3    )    )

									# Test 2-D numpy arrays are batched.
									UpperCAmelCase__    =							[floats_list((1, x)    )[0] for x in (800, 800, 800)]
									UpperCAmelCase__    =							np.asarray(lowerCamelCase__    )
									UpperCAmelCase__    =							feature_extractor(lowerCamelCase__					,return_tensors='np'    ).input_values
									UpperCAmelCase__    =							feature_extractor(lowerCamelCase__					,return_tensors='np'    ).input_values
									for enc_seq_a, enc_seq_a in zip(lowerCamelCase__					,lowerCamelCase__    ):
													self.assertTrue(np.allclose(lowerCamelCase__					,lowerCamelCase__					,atol=1e-3    )    )







					def 	__lowerCAmelCase		(       self     :			int    ):
									UpperCAmelCase__    =							self.feat_extract_tester.prepare_inputs_for_target()
									UpperCAmelCase__    =							self.feature_extraction_class(**self.feat_extract_dict    )
									UpperCAmelCase__    =							feat_extract.model_input_names[0]

									UpperCAmelCase__    =							BatchFeature({input_name: speech_inputs}    )

									self.assertTrue(all(len(lowerCamelCase__    ) == len(lowerCamelCase__    ) for x, y in zip(lowerCamelCase__					,processed_features[input_name]    )    )    )

									UpperCAmelCase__    =							self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCamelCase__    )
									UpperCAmelCase__    =							BatchFeature({input_name: speech_inputs}					,tensor_type='np'    )

									UpperCAmelCase__    =							processed_features[input_name]

									if len(batch_features_input.shape    ) < 3:
													UpperCAmelCase__    =							batch_features_input[:, :, None]

									self.assertTrue(
									    batch_features_input.shape
									    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]    ), self.feat_extract_tester.num_mel_bins)    )







					@require_torch
					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									UpperCAmelCase__    =							self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCamelCase__    )
									UpperCAmelCase__    =							self.feature_extraction_class(**self.feat_extract_dict    )
									UpperCAmelCase__    =							feat_extract.model_input_names[0]

									UpperCAmelCase__    =							BatchFeature({input_name: speech_inputs}					,tensor_type='pt'    )

									UpperCAmelCase__    =							processed_features[input_name]

									if len(batch_features_input.shape    ) < 3:
													UpperCAmelCase__    =							batch_features_input[:, :, None]

									self.assertTrue(
									    batch_features_input.shape
									    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]    ), self.feat_extract_tester.num_mel_bins)    )







					@require_torch
					def 	__lowerCAmelCase		(       self     :			List[Any]    ):
									UpperCAmelCase__    =							self.feature_extraction_class(**self.feat_extract_dict    )
									UpperCAmelCase__    =							self.feat_extract_tester.prepare_inputs_for_target()
									UpperCAmelCase__    =							feat_extract.model_input_names[0]

									UpperCAmelCase__    =							BatchFeature({input_name: speech_inputs}    )

									UpperCAmelCase__    =							feat_extract.num_mel_bins  # hack!

									UpperCAmelCase__    =							feat_extract.pad(lowerCamelCase__					,padding='longest'					,return_tensors='np'    )[input_name]
									UpperCAmelCase__    =							feat_extract.pad(lowerCamelCase__					,padding='longest'					,return_tensors='pt'    )[input_name]

									self.assertTrue(abs(input_np.astype(np.floataa    ).sum() - input_pt.numpy().astype(np.floataa    ).sum()    ) < 1e-2    )







					def 	__lowerCAmelCase		(       self     :			Union[str, Any]    ):
									UpperCAmelCase__    =							self.feat_extract_dict
									UpperCAmelCase__    =							True
									UpperCAmelCase__    =							self.feature_extraction_class(**lowerCamelCase__    )
									UpperCAmelCase__    =							self.feat_extract_tester.prepare_inputs_for_target()
									UpperCAmelCase__    =							[len(lowerCamelCase__    ) for x in speech_inputs]
									UpperCAmelCase__    =							feat_extract.model_input_names[0]

									UpperCAmelCase__    =							BatchFeature({input_name: speech_inputs}    )

									UpperCAmelCase__    =							feat_extract.num_mel_bins  # hack!

									UpperCAmelCase__    =							feat_extract.pad(lowerCamelCase__					,padding='longest'					,return_tensors='np'    )
									self.assertIn('attention_mask'					,lowerCamelCase__    )
									self.assertListEqual(list(processed.attention_mask.shape    )					,list(processed[input_name].shape[:2]    )    )
									self.assertListEqual(processed.attention_mask.sum(-1    ).tolist()					,lowerCamelCase__    )







					def 	__lowerCAmelCase		(       self     :			List[str]    ):
									UpperCAmelCase__    =							self.feat_extract_dict
									UpperCAmelCase__    =							True
									UpperCAmelCase__    =							self.feature_extraction_class(**lowerCamelCase__    )
									UpperCAmelCase__    =							self.feat_extract_tester.prepare_inputs_for_target()
									UpperCAmelCase__    =							[len(lowerCamelCase__    ) for x in speech_inputs]
									UpperCAmelCase__    =							feat_extract.model_input_names[0]

									UpperCAmelCase__    =							BatchFeature({input_name: speech_inputs}    )
									UpperCAmelCase__    =							min(lowerCamelCase__    )

									UpperCAmelCase__    =							feat_extract.num_mel_bins  # hack!

									UpperCAmelCase__    =							feat_extract.pad(
									    lowerCamelCase__					,padding='max_length'					,max_length=lowerCamelCase__					,truncation=lowerCamelCase__					,return_tensors='np'    )
									self.assertIn('attention_mask'					,lowerCamelCase__    )
									self.assertListEqual(
									    list(processed_pad.attention_mask.shape    )					,[processed_pad[input_name].shape[0], max_length]    )
									self.assertListEqual(
									    processed_pad.attention_mask[:, :max_length].sum(-1    ).tolist()					,[max_length for x in speech_inputs]    )







					def 	__lowerCAmelCase		(       self     :			Union[str, Any]					,lowerCamelCase__     :			Optional[int]    ):
									from datasets import load_dataset

									UpperCAmelCase__    =							load_dataset('hf-internal-testing/librispeech_asr_dummy'					,'clean'					,split='validation'    )
									# automatic decoding with librispeech
									UpperCAmelCase__    =							ds.sort('id'    ).select(range(lowerCamelCase__    )    )[:num_samples]['audio']

									return [x["array"] for x in speech_samples]







					def 	__lowerCAmelCase		(       self     :			Any    ):
									# fmt: off
									UpperCAmelCase__    =							torch.tensor(
									    [2.3804e-03, 2.0752e-03, 1.9836e-03, 2.1057e-03, 1.6174e-03,
									     3.0518e-04, 9.1553e-05, 3.3569e-04, 9.7656e-04, 1.8311e-03,
									     2.0142e-03, 2.1057e-03, 1.7395e-03, 4.5776e-04, -3.9673e-04,
									     4.5776e-04, 1.0071e-03, 9.1553e-05, 4.8828e-04, 1.1597e-03,
									     7.3242e-04, 9.4604e-04, 1.8005e-03, 1.8311e-03, 8.8501e-04,
									     4.2725e-04, 4.8828e-04, 7.3242e-04, 1.0986e-03, 2.1057e-03]    )
									# fmt: on

									UpperCAmelCase__    =							self._load_datasamples(1    )
									UpperCAmelCase__    =							SpeechTaFeatureExtractor()
									UpperCAmelCase__    =							feature_extractor(lowerCamelCase__					,return_tensors='pt'    ).input_values
									self.assertEquals(input_values.shape					,(1, 93_680)    )
									self.assertTrue(torch.allclose(input_values[0, :30]					,lowerCamelCase__					,atol=1e-6    )    )







					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									# fmt: off
									UpperCAmelCase__    =							torch.tensor(
									    [-2.6_8_7_0, -3.0_1_0_4, -3.1_3_5_6, -3.5_3_5_2, -3.0_0_4_4, -3.0_3_5_3, -3.4_7_1_9, -3.6_7_7_7,
									     -3.1_5_2_0, -2.9_4_3_5, -2.6_5_5_3, -2.8_7_9_5, -2.9_9_4_4, -2.5_9_2_1, -3.0_2_7_9, -3.0_3_8_6,
									     -3.0_8_6_4, -3.1_2_9_1, -3.2_3_5_3, -2.7_4_4_4, -2.6_8_3_1, -2.7_2_8_7, -3.1_7_6_1, -3.1_5_7_1,
									     -3.2_7_2_6, -3.0_5_8_2, -3.1_0_0_7, -3.4_5_3_3, -3.4_6_9_5, -3.0_9_9_8]    )
									# fmt: on

									UpperCAmelCase__    =							self._load_datasamples(1    )
									UpperCAmelCase__    =							SpeechTaFeatureExtractor()
									UpperCAmelCase__    =							feature_extractor(audio_target=lowerCamelCase__					,return_tensors='pt'    ).input_values
									self.assertEquals(input_values.shape					,(1, 366, 80)    )
									self.assertTrue(torch.allclose(input_values[0, 0, :30]					,lowerCamelCase__					,atol=1e-4    )    )




"""simple docstring"""






from __future__ import annotations

import string
from itertools import cycle, product
from pathlib import Path

lowerCAmelCase__						:						str		  =			(
    string.ascii_letters + string.digits + string.punctuation + string.whitespace
)
lowerCAmelCase__						:						list[int]		  =			[ord(letter) for letter in string.ascii_lowercase]
lowerCAmelCase__						:						set[int]		  =			{ord(char) for char in VALID_CHARS}

lowerCAmelCase__						:						list[str]		  =			["the", "be", "to", "of", "and", "in", "that", "have"]



def 						a_		(      lowerCamelCase      ,    lowerCamelCase ):
				UpperCAmelCase__    =							""
				UpperCAmelCase__    =							42
				UpperCAmelCase__    =							42
				UpperCAmelCase__    =							42

				for keychar, cipherchar in zip(cycle(lowerCamelCase )      ,    lowerCamelCase ):
								UpperCAmelCase__    =							cipherchar ^ keychar
								if decodedchar not in VALID_INTS:
												return None
								decoded += chr(lowerCamelCase )

				return decoded



def 						a_		(      lowerCamelCase ):
				UpperCAmelCase__    =							[]
				for key in product(lowerCamelCase      ,    repeat=3 ):
								UpperCAmelCase__    =							try_key(lowerCamelCase      ,    lowerCamelCase )
								if encoded is not None:
												possibles.append(lowerCamelCase )
				return possibles



def 						a_		(      lowerCamelCase      ,    lowerCamelCase ):
				return [possible for possible in possibles if common_word in possible.lower()]



def 						a_		(      lowerCamelCase = "p059_cipher.txt" ):
				UpperCAmelCase__    =							42
				UpperCAmelCase__    =							42
				UpperCAmelCase__    =							42
				UpperCAmelCase__    =							42
				UpperCAmelCase__    =							Path(lowerCamelCase ).parent.joinpath(lowerCamelCase ).read_text(encoding='utf-8' )

				UpperCAmelCase__    =							[int(lowerCamelCase ) for number in data.strip().split(',' )]

				UpperCAmelCase__    =							filter_valid_chars(lowerCamelCase )
				for common_word in COMMON_WORDS:
								UpperCAmelCase__    =							filter_common_word(lowerCamelCase      ,    lowerCamelCase )
								if len(lowerCamelCase ) == 1:
												break

				UpperCAmelCase__    =							possibles[0]
				return sum(ord(lowerCamelCase ) for char in decoded_text )


if __name__ == "__main__":
						print(F"""{solution() = }""")



