





'''simple docstring'''


import json
import os
import shutil
import tempfile
import unittest
from multiprocessing import get_context
from pathlib import Path

import datasets
import numpy as np
from datasets import load_dataset
from parameterized import parameterized

from transformers import AutoProcessor
from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.testing_utils import require_pyctcdecode, require_torch, require_torchaudio, slow
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_pyctcdecode_available, is_torch_available

from ..wavaveca.test_feature_extraction_wavaveca import floats_list


if is_pyctcdecode_available():
    from huggingface_hub import snapshot_download
    from pyctcdecode import BeamSearchDecoderCTC

    from transformers.models.wavaveca_with_lm import WavaVecaProcessorWithLM
    from transformers.models.wavaveca_with_lm.processing_wavaveca_with_lm import WavaVecaDecoderWithLMOutput

if is_torch_available():
    from transformers import WavaVecaForCTC






@require_pyctcdecode
class     lowerCAmelCase__ (				unittest.TestCase    ):

       '''simple docstring'''

       def 			__snake_case      ( self					:				Optional[int]						):
              UpperCAmelCase  =						'''| <pad> <unk> <s> </s> a b c d e f g h i j k'''.split()
              UpperCAmelCase  =						dict(zip(a__       ,     range(len(a__						)						)						)						)

              UpperCAmelCase  =						{
                  '''unk_token''': '''<unk>''',
                  '''bos_token''': '''<s>''',
                  '''eos_token''': '''</s>''',
              }
              UpperCAmelCase  =						{
                  '''feature_size''': 1,
                  '''padding_value''': 0.0,
                  '''sampling_rate''': 16000,
                  '''return_attention_mask''': False,
                  '''do_normalize''': True,
              }

              UpperCAmelCase  =						tempfile.mkdtemp()
              UpperCAmelCase  =						os.path.join(self.tmpdirname       ,     VOCAB_FILES_NAMES['''vocab_file''']						)
              UpperCAmelCase  =						os.path.join(self.tmpdirname       ,     a__						)
              with open(self.vocab_file       ,     '''w'''       ,     encoding='''utf-8'''						) as fp:
                     fp.write(json.dumps(a__						) + '''\n'''						)

              with open(self.feature_extraction_file       ,     '''w'''       ,     encoding='''utf-8'''						) as fp:
                     fp.write(json.dumps(a__						) + '''\n'''						)

              # load decoder from hub
              UpperCAmelCase  =						'''hf-internal-testing/ngram-beam-search-decoder'''

       def 			__snake_case      ( self					:				int       ,     **a__					:				Optional[int]						):
              UpperCAmelCase  =						self.add_kwargs_tokens_map.copy()
              kwargs.update(a__						)
              return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname       ,     **a__						)

       def 			__snake_case      ( self					:				int       ,     **a__					:				str						):
              return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname       ,     **a__						)

       def 			__snake_case      ( self					:				List[str]       ,     **a__					:				Optional[Any]						):
              return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name       ,     **a__						)

       def 			__snake_case      ( self					:				int						):
              shutil.rmtree(self.tmpdirname						)

       def 			__snake_case      ( self					:				Optional[int]						):
              UpperCAmelCase  =						self.get_tokenizer()
              UpperCAmelCase  =						self.get_feature_extractor()
              UpperCAmelCase  =						self.get_decoder()

              UpperCAmelCase  =						WavaVecaProcessorWithLM(tokenizer=a__       ,     feature_extractor=a__       ,     decoder=a__						)

              processor.save_pretrained(self.tmpdirname						)
              UpperCAmelCase  =						WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname						)

              # tokenizer
              self.assertEqual(processor.tokenizer.get_vocab()       ,     tokenizer.get_vocab()						)
              self.assertIsInstance(processor.tokenizer       ,     a__						)

              # feature extractor
              self.assertEqual(processor.feature_extractor.to_json_string()       ,     feature_extractor.to_json_string()						)
              self.assertIsInstance(processor.feature_extractor       ,     a__						)

              # decoder
              self.assertEqual(processor.decoder._alphabet.labels       ,     decoder._alphabet.labels						)
              self.assertEqual(
                  processor.decoder.model_container[decoder._model_key]._unigram_set       ,     decoder.model_container[decoder._model_key]._unigram_set       ,     )
              self.assertIsInstance(processor.decoder       ,     a__						)

       def 			__snake_case      ( self					:				Any						):
              UpperCAmelCase  =						WavaVecaProcessorWithLM(
                  tokenizer=self.get_tokenizer()       ,     feature_extractor=self.get_feature_extractor()       ,     decoder=self.get_decoder()						)
              processor.save_pretrained(self.tmpdirname						)

              # make sure that error is thrown when decoder alphabet doesn't match
              UpperCAmelCase  =						WavaVecaProcessorWithLM.from_pretrained(
                  self.tmpdirname       ,     alpha=5.0       ,     beta=3.0       ,     score_boundary=-7.0       ,     unk_score_offset=3						)

              # decoder
              self.assertEqual(processor.language_model.alpha       ,     5.0						)
              self.assertEqual(processor.language_model.beta       ,     3.0						)
              self.assertEqual(processor.language_model.score_boundary       ,     -7.0						)
              self.assertEqual(processor.language_model.unk_score_offset       ,     3						)

       def 			__snake_case      ( self					:				Optional[int]						):
              UpperCAmelCase  =						self.get_tokenizer()
              # add token to trigger raise
              tokenizer.add_tokens(['''xx''']						)
              with self.assertRaisesRegex(a__       ,     '''include'''						):
                     WavaVecaProcessorWithLM(
                         tokenizer=a__       ,     feature_extractor=self.get_feature_extractor()       ,     decoder=self.get_decoder()						)

       def 			__snake_case      ( self					:				Optional[int]						):
              UpperCAmelCase  =						self.get_feature_extractor()
              UpperCAmelCase  =						self.get_tokenizer()
              UpperCAmelCase  =						self.get_decoder()

              UpperCAmelCase  =						WavaVecaProcessorWithLM(tokenizer=a__       ,     feature_extractor=a__       ,     decoder=a__						)

              UpperCAmelCase  =						floats_list((3, 1000)						)

              UpperCAmelCase  =						feature_extractor(a__       ,     return_tensors='''np'''						)
              UpperCAmelCase  =						processor(a__       ,     return_tensors='''np'''						)

              for key in input_feat_extract.keys():
                     self.assertAlmostEqual(input_feat_extract[key].sum()       ,     input_processor[key].sum()       ,     delta=1e-2						)

       def 			__snake_case      ( self					:				Any						):
              UpperCAmelCase  =						self.get_feature_extractor()
              UpperCAmelCase  =						self.get_tokenizer()
              UpperCAmelCase  =						self.get_decoder()

              UpperCAmelCase  =						WavaVecaProcessorWithLM(tokenizer=a__       ,     feature_extractor=a__       ,     decoder=a__						)

              UpperCAmelCase  =						'''This is a test string'''

              UpperCAmelCase  =						processor(text=a__						)

              UpperCAmelCase  =						tokenizer(a__						)

              for key in encoded_tok.keys():
                     self.assertListEqual(encoded_tok[key]       ,     encoded_processor[key]						)

       def 			__snake_case      ( self					:				int       ,     a__					:				int=(2, 10, 16)       ,     a__					:				List[Any]=77						):
              np.random.seed(a__						)
              return np.random.rand(*a__						)

       def 			__snake_case      ( self					:				Optional[Any]						):
              UpperCAmelCase  =						self.get_feature_extractor()
              UpperCAmelCase  =						self.get_tokenizer()
              UpperCAmelCase  =						self.get_decoder()

              UpperCAmelCase  =						WavaVecaProcessorWithLM(tokenizer=a__       ,     feature_extractor=a__       ,     decoder=a__						)

              UpperCAmelCase  =						self._get_dummy_logits(shape=(10, 16)       ,     seed=13						)

              UpperCAmelCase  =						processor.decode(a__						)

              UpperCAmelCase  =						decoder.decode_beams(a__						)[0]

              self.assertEqual(decoded_decoder[0]       ,     decoded_processor.text						)
              self.assertEqual('''</s> <s> </s>'''       ,     decoded_processor.text						)
              self.assertEqual(decoded_decoder[-2]       ,     decoded_processor.logit_score						)
              self.assertEqual(decoded_decoder[-1]       ,     decoded_processor.lm_score						)

       @parameterized.expand([[None], ['''fork'''], ['''spawn''']]						)
       def 			__snake_case      ( self					:				Any       ,     a__					:				str						):
              UpperCAmelCase  =						self.get_feature_extractor()
              UpperCAmelCase  =						self.get_tokenizer()
              UpperCAmelCase  =						self.get_decoder()

              UpperCAmelCase  =						WavaVecaProcessorWithLM(tokenizer=a__       ,     feature_extractor=a__       ,     decoder=a__						)

              UpperCAmelCase  =						self._get_dummy_logits()

              # note: pool should be instantiated *after* Wav2Vec2ProcessorWithLM.
              #       otherwise, the LM won't be available to the pool's sub-processes.
              # manual logic used to allow parameterized test for both pool=None and pool=Pool(...)
              if pool_context is None:
                     UpperCAmelCase  =						processor.batch_decode(a__						)
              else:
                     with get_context(a__						).Pool() as pool:
                            UpperCAmelCase  =						processor.batch_decode(a__       ,     a__						)

              UpperCAmelCase  =						list(a__						)

              with get_context('''fork'''						).Pool() as p:
                     UpperCAmelCase  =						decoder.decode_beams_batch(a__       ,     a__						)

              UpperCAmelCase,					UpperCAmelCase,					UpperCAmelCase  =						[], [], []
              for beams in decoded_beams:
                     texts_decoder.append(beams[0][0]						)
                     logit_scores_decoder.append(beams[0][-2]						)
                     lm_scores_decoder.append(beams[0][-1]						)

              self.assertListEqual(a__       ,     decoded_processor.text						)
              self.assertListEqual(['''<s> <s> </s>''', '''<s> <s> <s>''']       ,     decoded_processor.text						)
              self.assertListEqual(a__       ,     decoded_processor.logit_score						)
              self.assertListEqual(a__       ,     decoded_processor.lm_score						)

       def 			__snake_case      ( self					:				Dict						):
              UpperCAmelCase  =						self.get_feature_extractor()
              UpperCAmelCase  =						self.get_tokenizer()
              UpperCAmelCase  =						self.get_decoder()

              UpperCAmelCase  =						WavaVecaProcessorWithLM(tokenizer=a__       ,     feature_extractor=a__       ,     decoder=a__						)

              UpperCAmelCase  =						self._get_dummy_logits()

              UpperCAmelCase  =						15
              UpperCAmelCase  =						-20.0
              UpperCAmelCase  =						-4.0

              UpperCAmelCase  =						processor.batch_decode(
                  a__       ,     beam_width=a__       ,     beam_prune_logp=a__       ,     token_min_logp=a__       ,     )
              UpperCAmelCase  =						decoded_processor_out.text

              UpperCAmelCase  =						list(a__						)

              with get_context('''fork'''						).Pool() as pool:
                     UpperCAmelCase  =						decoder.decode_beams_batch(
                         a__       ,     a__       ,     beam_width=a__       ,     beam_prune_logp=a__       ,     token_min_logp=a__       ,     )

              UpperCAmelCase  =						[d[0][0] for d in decoded_decoder_out]
              UpperCAmelCase  =						[d[0][2] for d in decoded_decoder_out]
              UpperCAmelCase  =						[d[0][3] for d in decoded_decoder_out]

              self.assertListEqual(a__       ,     a__						)
              self.assertListEqual(['''</s> <s> <s>''', '''<s> <s> <s>''']       ,     a__						)

              self.assertTrue(np.array_equal(a__       ,     decoded_processor_out.logit_score						)						)
              self.assertTrue(np.allclose([-20.054, -18.447]       ,     a__       ,     atol=1e-3						)						)

              self.assertTrue(np.array_equal(a__       ,     decoded_processor_out.lm_score						)						)
              self.assertTrue(np.allclose([-15.554, -13.9_474]       ,     a__       ,     atol=1e-3						)						)

       def 			__snake_case      ( self					:				Union[str, Any]						):
              UpperCAmelCase  =						self.get_feature_extractor()
              UpperCAmelCase  =						self.get_tokenizer()
              UpperCAmelCase  =						self.get_decoder()

              UpperCAmelCase  =						WavaVecaProcessorWithLM(tokenizer=a__       ,     feature_extractor=a__       ,     decoder=a__						)

              UpperCAmelCase  =						self._get_dummy_logits()

              UpperCAmelCase  =						2.0
              UpperCAmelCase  =						5.0
              UpperCAmelCase  =						-20.0
              UpperCAmelCase  =						True

              UpperCAmelCase  =						processor.batch_decode(
                  a__       ,     alpha=a__       ,     beta=a__       ,     unk_score_offset=a__       ,     lm_score_boundary=a__       ,     )
              UpperCAmelCase  =						decoded_processor_out.text

              UpperCAmelCase  =						list(a__						)
              decoder.reset_params(
                  alpha=a__       ,     beta=a__       ,     unk_score_offset=a__       ,     lm_score_boundary=a__       ,     )

              with get_context('''fork'''						).Pool() as pool:
                     UpperCAmelCase  =						decoder.decode_beams_batch(
                         a__       ,     a__       ,     )

              UpperCAmelCase  =						[d[0][0] for d in decoded_decoder_out]

              self.assertListEqual(a__       ,     a__						)
              self.assertListEqual(['''<s> </s> <s> </s> </s>''', '''</s> </s> <s> </s> </s>''']       ,     a__						)
              UpperCAmelCase  =						processor.decoder.model_container[processor.decoder._model_key]
              self.assertEqual(lm_model.alpha       ,     2.0						)
              self.assertEqual(lm_model.beta       ,     5.0						)
              self.assertEqual(lm_model.unk_score_offset       ,     -20.0						)
              self.assertEqual(lm_model.score_boundary       ,     a__						)

       def 			__snake_case      ( self					:				List[Any]						):
              UpperCAmelCase  =						WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''						)

              UpperCAmelCase  =						processor.decoder.model_container[processor.decoder._model_key]
              UpperCAmelCase  =						Path(language_model._kenlm_model.path.decode('''utf-8'''						)						).parent.parent.absolute()

              UpperCAmelCase  =						os.listdir(a__						)
              UpperCAmelCase  =						['''alphabet.json''', '''language_model''']

              downloaded_decoder_files.sort()
              expected_decoder_files.sort()

              # test that only decoder relevant files from
              # https://huggingface.co/hf-internal-testing/processor_with_lm/tree/main
              # are downloaded and none of the rest (e.g. README.md, ...)
              self.assertListEqual(a__       ,     a__						)

       def 			__snake_case      ( self					:				str						):
              UpperCAmelCase  =						snapshot_download('''hf-internal-testing/processor_with_lm'''						)

              UpperCAmelCase  =						WavaVecaProcessorWithLM.from_pretrained(a__						)

              UpperCAmelCase  =						processor.decoder.model_container[processor.decoder._model_key]
              UpperCAmelCase  =						Path(language_model._kenlm_model.path.decode('''utf-8'''						)						).parent.parent.absolute()

              UpperCAmelCase  =						os.listdir(a__						)
              UpperCAmelCase  =						os.listdir(a__						)

              local_decoder_files.sort()
              expected_decoder_files.sort()

              # test that both decoder form hub and local files in cache are the same
              self.assertListEqual(a__       ,     a__						)

       def 			__snake_case      ( self					:				List[Any]						):
              UpperCAmelCase  =						WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''						)
              UpperCAmelCase  =						AutoProcessor.from_pretrained('''hf-internal-testing/processor_with_lm'''						)

              UpperCAmelCase  =						floats_list((3, 1000)						)

              UpperCAmelCase  =						processor_wavaveca(a__       ,     return_tensors='''np'''						)
              UpperCAmelCase  =						processor_auto(a__       ,     return_tensors='''np'''						)

              for key in input_wavaveca.keys():
                     self.assertAlmostEqual(input_wavaveca[key].sum()       ,     input_auto[key].sum()       ,     delta=1e-2						)

              UpperCAmelCase  =						self._get_dummy_logits()

              UpperCAmelCase  =						processor_wavaveca.batch_decode(a__						)
              UpperCAmelCase  =						processor_auto.batch_decode(a__						)

              self.assertListEqual(decoded_wavaveca.text       ,     decoded_auto.text						)

       def 			__snake_case      ( self					:				Union[str, Any]						):
              UpperCAmelCase  =						self.get_feature_extractor()
              UpperCAmelCase  =						self.get_tokenizer()
              UpperCAmelCase  =						self.get_decoder()

              UpperCAmelCase  =						WavaVecaProcessorWithLM(tokenizer=a__       ,     feature_extractor=a__       ,     decoder=a__						)

              self.assertListEqual(
                  processor.model_input_names       ,     feature_extractor.model_input_names       ,     msg='''`processor` and `feature_extractor` model input names do not match'''       ,     )

       @staticmethod
       def 			__snake_case      ( a__					:				Tuple       ,     a__					:				int						):
              UpperCAmelCase  =						[d[key] for d in offsets]
              return retrieved_list

       def 			__snake_case      ( self					:				Dict						):
              UpperCAmelCase  =						WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''						)
              UpperCAmelCase  =						self._get_dummy_logits()[0]

              UpperCAmelCase  =						processor.decode(a__       ,     output_word_offsets=a__						)
              # check Wav2Vec2CTCTokenizerOutput keys for word
              self.assertEqual(len(outputs.keys()						)       ,     4						)
              self.assertTrue('''text''' in outputs						)
              self.assertTrue('''word_offsets''' in outputs						)
              self.assertTrue(isinstance(a__       ,     a__						)						)

              self.assertEqual(''' '''.join(self.get_from_offsets(outputs['''word_offsets''']       ,     '''word'''						)						)       ,     outputs.text						)
              self.assertListEqual(self.get_from_offsets(outputs['''word_offsets''']       ,     '''word'''						)       ,     ['''<s>''', '''<s>''', '''</s>''']						)
              self.assertListEqual(self.get_from_offsets(outputs['''word_offsets''']       ,     '''start_offset'''						)       ,     [0, 2, 4]						)
              self.assertListEqual(self.get_from_offsets(outputs['''word_offsets''']       ,     '''end_offset'''						)       ,     [1, 3, 5]						)

       def 			__snake_case      ( self					:				Any						):
              UpperCAmelCase  =						WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''						)
              UpperCAmelCase  =						self._get_dummy_logits()

              UpperCAmelCase  =						processor.batch_decode(a__       ,     output_word_offsets=a__						)

              # check Wav2Vec2CTCTokenizerOutput keys for word
              self.assertEqual(len(outputs.keys()						)       ,     4						)
              self.assertTrue('''text''' in outputs						)
              self.assertTrue('''word_offsets''' in outputs						)
              self.assertTrue(isinstance(a__       ,     a__						)						)

              self.assertListEqual(
                  [''' '''.join(self.get_from_offsets(a__       ,     '''word'''						)						) for o in outputs['''word_offsets''']]       ,     outputs.text						)
              self.assertListEqual(self.get_from_offsets(outputs['''word_offsets'''][0]       ,     '''word'''						)       ,     ['''<s>''', '''<s>''', '''</s>''']						)
              self.assertListEqual(self.get_from_offsets(outputs['''word_offsets'''][0]       ,     '''start_offset'''						)       ,     [0, 2, 4]						)
              self.assertListEqual(self.get_from_offsets(outputs['''word_offsets'''][0]       ,     '''end_offset'''						)       ,     [1, 3, 5]						)



       @slow
       @require_torch
       @require_torchaudio
       def 			__snake_case      ( self					:				Dict						):
              import torch

              UpperCAmelCase  =						load_dataset('''common_voice'''       ,     '''en'''       ,     split='''train'''       ,     streaming=a__						)
              UpperCAmelCase  =						ds.cast_column('''audio'''       ,     datasets.Audio(sampling_rate=16000						)						)
              UpperCAmelCase  =						iter(a__						)
              UpperCAmelCase  =						next(a__						)

              UpperCAmelCase  =						AutoProcessor.from_pretrained('''patrickvonplaten/wav2vec2-base-100h-with-lm'''						)
              UpperCAmelCase  =						WavaVecaForCTC.from_pretrained('''patrickvonplaten/wav2vec2-base-100h-with-lm'''						)

              # compare to filename `common_voice_en_100038.mp3` of dataset viewer on https://huggingface.co/datasets/common_voice/viewer/en/train
              UpperCAmelCase  =						processor(sample['''audio''']['''array''']       ,     return_tensors='''pt'''						).input_values

              with torch.no_grad():
                     UpperCAmelCase  =						model(a__						).logits.cpu().numpy()

              UpperCAmelCase  =						processor.decode(logits[0]       ,     output_word_offsets=a__						)

              UpperCAmelCase  =						model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
              UpperCAmelCase  =						[
                  {
                      '''start_time''': d['''start_offset'''] * time_offset,
                      '''end_time''': d['''end_offset'''] * time_offset,
                      '''word''': d['''word'''],
                  }
                  for d in output['''word_offsets''']
              ]

              UpperCAmelCase  =						'''WHY DOES MILISANDRA LOOK LIKE SHE WANTS TO CONSUME JOHN SNOW ON THE RIVER AT THE WALL'''

              # output words
              self.assertEqual(''' '''.join(self.get_from_offsets(a__       ,     '''word'''						)						)       ,     a__						)
              self.assertEqual(''' '''.join(self.get_from_offsets(a__       ,     '''word'''						)						)       ,     output.text						)

              # output times
              UpperCAmelCase  =						torch.tensor(self.get_from_offsets(a__       ,     '''start_time'''						)						)
              UpperCAmelCase  =						torch.tensor(self.get_from_offsets(a__       ,     '''end_time'''						)						)

              # fmt: off
              UpperCAmelCase  =						torch.tensor([1.4_199, 1.6_599, 2.2_599, 3.0, 3.24, 3.5_999, 3.7_999, 4.0_999, 4.26, 4.94, 5.28, 5.6_599, 5.78, 5.94, 6.32, 6.5_399, 6.6_599]						)
              UpperCAmelCase  =						torch.tensor([1.5_399, 1.8_999, 2.9, 3.16, 3.5_399, 3.72, 4.0_199, 4.1_799, 4.76, 5.1_599, 5.5_599, 5.6_999, 5.86, 6.1_999, 6.38, 6.6_199, 6.94]						)
              # fmt: on

              self.assertTrue(torch.allclose(a__       ,     a__       ,     atol=0.01						)						)
              self.assertTrue(torch.allclose(a__       ,     a__       ,     atol=0.01						)						)




def 		UpperCamelCase     (       _UpperCAmelCase  :   list[int] ,			_UpperCAmelCase  :   list[int]  )   ->			tuple[float, float]:






						'''simple docstring'''

						if not len(_UpperCAmelCase  ) == len(_UpperCAmelCase  ) == 3:
												raise ValueError("Please enter a valid equation."  )
						if equationa[0] == equationa[1] == equationa[0] == equationa[1] == 0:
												raise ValueError("Both a & b of two equations can't be zero."  )

						# Extract the coefficients
						_lowercase      ,    _lowercase      ,    _lowercase       :	List[str]           =   equationa
						_lowercase      ,    _lowercase      ,    _lowercase       :	List[str]           =   equationa

						# Calculate the determinants of the matrices
						_lowercase       :	List[Any]           =   aa * ba - aa * ba
						_lowercase       :	Tuple           =   ca * ba - ca * ba
						_lowercase       :	Union[str, Any]           =   aa * ca - aa * ca

						# Check if the system of linear equations has a solution (using Cramer's rule)
						if determinant == 0:
												if determinant_x == determinant_y == 0:
																		raise ValueError("Infinite solutions. (Consistent system)"  )
												else:
																		raise ValueError("No solution. (Inconsistent system)"  )
						else:
												if determinant_x == determinant_y == 0:
																		# Trivial solution (Inconsistent system)
																		return (0.0, 0.0)
												else:
																		_lowercase       :	str           =   determinant_x / determinant
																		_lowercase       :	Union[str, Any]           =   determinant_y / determinant
																		# Non-Trivial Solution (Consistent system)
																		return (x, y)




