
import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)

from ...test_tokenization_common import TokenizerTesterMixin


lowercase__		:Optional[int]			  =   get_tests_dir("fixtures/test_sentencepiece.model")

if is_torch_available():
							from transformers.models.mbart.modeling_mbart import shift_tokens_right

lowercase__		:str			  =   25_0004
lowercase__		:int			  =   25_0020







@require_sentencepiece
@require_tokenizers
class     lowercase		( __SCREAMING_SNAKE_CASE	,  unittest.TestCase		):
							lowercase_	:	Any	 =MBartaaTokenizer
							lowercase_	:	Dict	 =MBartaaTokenizerFast
							lowercase_	:	Tuple	 =True
							lowercase_	:	int	 =True




							def 			A__				(    self):
												super().setUp()

												# We have a SentencePiece fixture for testing
												lowercase						     =						MBartaaTokenizer(UpperCamelCase__       ,src_lang='''en_XX'''       ,tgt_lang='''ro_RO'''       ,keep_accents=UpperCamelCase__)
												tokenizer.save_pretrained(self.tmpdirname)




							def 			A__				(    self):
												lowercase						     =						'''<s>'''
												lowercase						     =						0

												self.assertEqual(self.get_tokenizer()._convert_token_to_id(UpperCamelCase__)       ,UpperCamelCase__)
												self.assertEqual(self.get_tokenizer()._convert_id_to_token(UpperCamelCase__)       ,UpperCamelCase__)




							def 			A__				(    self):
												lowercase						     =						list(self.get_tokenizer().get_vocab().keys())

												self.assertEqual(vocab_keys[0]       ,'''<s>''')
												self.assertEqual(vocab_keys[1]       ,'''<pad>''')
												self.assertEqual(vocab_keys[-1]       ,'''<mask>''')
												self.assertEqual(len(UpperCamelCase__)       ,1_0_5_4)




							def 			A__				(    self):
												self.assertEqual(self.get_tokenizer().vocab_size       ,1_0_5_4)




							def 			A__				(    self):
												lowercase						     =						MBartaaTokenizer(UpperCamelCase__       ,src_lang='''en_XX'''       ,tgt_lang='''ro_RO'''       ,keep_accents=UpperCamelCase__)

												lowercase						     =						tokenizer.tokenize('''This is a test''')
												self.assertListEqual(UpperCamelCase__       ,['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''])

												self.assertListEqual(
												    tokenizer.convert_tokens_to_ids(UpperCamelCase__)       ,[value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]]       ,)

												lowercase						     =						tokenizer.tokenize('''I was born in 92000, and this is falsé.''')
												self.assertListEqual(
												    UpperCamelCase__       ,[SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''9''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''é''', '''.''']       ,)
												lowercase						     =						tokenizer.convert_tokens_to_ids(UpperCamelCase__)
												self.assertListEqual(
												    UpperCamelCase__       ,[
												        value + tokenizer.fairseq_offset
												        for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
												    ]       ,)

												lowercase						     =						tokenizer.convert_ids_to_tokens(UpperCamelCase__)
												self.assertListEqual(
												    UpperCamelCase__       ,[SPIECE_UNDERLINE + '''I''', SPIECE_UNDERLINE + '''was''', SPIECE_UNDERLINE + '''b''', '''or''', '''n''', SPIECE_UNDERLINE + '''in''', SPIECE_UNDERLINE + '''''', '''<unk>''', '''2''', '''0''', '''0''', '''0''', ''',''', SPIECE_UNDERLINE + '''and''', SPIECE_UNDERLINE + '''this''', SPIECE_UNDERLINE + '''is''', SPIECE_UNDERLINE + '''f''', '''al''', '''s''', '''<unk>''', '''.''']       ,)




							@slow
							def 			A__				(    self):
												lowercase						     =						{'''input_ids''': [[2_5_0_0_0_4, 1_1_0_6_2, 8_2_7_7_2, 7, 1_5, 8_2_7_7_2, 5_3_8, 5_1_5_2_9, 2_3_7, 1_7_1_9_8, 1_2_9_0, 2_0_6, 9, 2_1_5_1_7_5, 1_3_1_4, 1_3_6, 1_7_1_9_8, 1_2_9_0, 2_0_6, 9, 5_6_3_5_9, 4_2, 1_2_2_0_0_9, 9, 1_6_4_6_6, 1_6, 8_7_3_4_4, 4_5_3_7, 9, 4_7_1_7, 7_8_3_8_1, 6, 1_5_9_9_5_8, 7, 1_5, 2_4_4_8_0, 6_1_8, 4, 5_2_7, 2_2_6_9_3, 5_4_2_8, 4, 2_7_7_7, 2_4_4_8_0, 9_8_7_4, 4, 4_3_5_2_3, 5_9_4, 4, 8_0_3, 1_8_3_9_2, 3_3_1_8_9, 1_8, 4, 4_3_5_2_3, 2_4_4_4_7, 1_2_3_9_9, 1_0_0, 2_4_9_5_5, 8_3_6_5_8, 9_6_2_6, 1_4_4_0_5_7, 1_5, 8_3_9, 2_2_3_3_5, 1_6, 1_3_6, 2_4_9_5_5, 8_3_6_5_8, 8_3_4_7_9, 1_5, 3_9_1_0_2, 7_2_4, 1_6, 6_7_8, 6_4_5, 2_7_8_9, 1_3_2_8, 4_5_8_9, 4_2, 1_2_2_0_0_9, 1_1_5_7_7_4, 2_3, 8_0_5, 1_3_2_8, 4_6_8_7_6, 7, 1_3_6, 5_3_8_9_4, 1_9_4_0, 4_2_2_2_7, 4_1_1_5_9, 1_7_7_2_1, 8_2_3, 4_2_5, 4, 2_7_5_1_2, 9_8_7_2_2, 2_0_6, 1_3_6, 5_5_3_1, 4_9_7_0, 9_1_9, 1_7_3_3_6, 5, 2], [2_5_0_0_0_4, 2_0_0_8_0, 6_1_8, 8_3, 8_2_7_7_5, 4_7, 4_7_9, 9, 1_5_1_7, 7_3, 5_3_8_9_4, 3_3_3, 8_0_5_8_1, 1_1_0_1_1_7, 1_8_8_1_1, 5_2_5_6, 1_2_9_5, 5_1, 1_5_2_5_2_6, 2_9_7, 7_9_8_6, 3_9_0, 1_2_4_4_1_6, 5_3_8, 3_5_4_3_1, 2_1_4, 9_8, 1_5_0_4_4, 2_5_7_3_7, 1_3_6, 7_1_0_8, 4_3_7_0_1, 2_3, 7_5_6, 1_3_5_3_5_5, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [2_5_0_0_0_4, 5_8_1, 6_3_7_7_3, 1_1_9_4_5_5, 6, 1_4_7_7_9_7, 8_8_2_0_3, 7, 6_4_5, 7_0, 2_1, 3_2_8_5, 1_0_2_6_9, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
												# fmt: on

												self.tokenizer_integration_test_util(
												    expected_encoding=UpperCamelCase__       ,model_name='''facebook/mbart-large-50'''       ,revision='''d3913889c59cd5c9e456b269c376325eabad57e2'''       ,)





							def 			A__				(    self):







												if not self.test_slow_tokenizer:
																	# as we don't have a slow version, we can't compare the outputs between slow and fast versions
																	return

												lowercase						     =						(self.rust_tokenizer_class, '''hf-internal-testing/tiny-random-mbart50''', {})
												for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																	with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'):
																						lowercase						     =						self.rust_tokenizer_class.from_pretrained(UpperCamelCase__       ,**UpperCamelCase__)
																						lowercase						     =						self.tokenizer_class.from_pretrained(UpperCamelCase__       ,**UpperCamelCase__)

																						lowercase						     =						tempfile.mkdtemp()

																						lowercase						     =						tokenizer_r.save_pretrained(UpperCamelCase__)
																						lowercase						     =						tokenizer_p.save_pretrained(UpperCamelCase__)

																						# Checks it save with the same files + the tokenizer.json file for the fast one
																						self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files))
																						lowercase						     =						tuple(f for f in tokenizer_r_files if '''tokenizer.json''' not in f)
																						self.assertSequenceEqual(UpperCamelCase__       ,UpperCamelCase__)

																						# Checks everything loads correctly in the same way
																						lowercase						     =						tokenizer_r.from_pretrained(UpperCamelCase__)
																						lowercase						     =						tokenizer_p.from_pretrained(UpperCamelCase__)

																						# Check special tokens are set accordingly on Rust and Python
																						for key in tokenizer_pp.special_tokens_map:
																											self.assertTrue(hasattr(UpperCamelCase__       ,UpperCamelCase__))
																											# self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
																											# self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

																						shutil.rmtree(UpperCamelCase__)

																						# Save tokenizer rust, legacy_format=True
																						lowercase						     =						tempfile.mkdtemp()

																						lowercase						     =						tokenizer_r.save_pretrained(UpperCamelCase__       ,legacy_format=UpperCamelCase__)
																						lowercase						     =						tokenizer_p.save_pretrained(UpperCamelCase__)

																						# Checks it save with the same files
																						self.assertSequenceEqual(UpperCamelCase__       ,UpperCamelCase__)

																						# Checks everything loads correctly in the same way
																						lowercase						     =						tokenizer_r.from_pretrained(UpperCamelCase__)
																						lowercase						     =						tokenizer_p.from_pretrained(UpperCamelCase__)

																						# Check special tokens are set accordingly on Rust and Python
																						for key in tokenizer_pp.special_tokens_map:
																											self.assertTrue(hasattr(UpperCamelCase__       ,UpperCamelCase__))

																						shutil.rmtree(UpperCamelCase__)

																						# Save tokenizer rust, legacy_format=False
																						lowercase						     =						tempfile.mkdtemp()

																						lowercase						     =						tokenizer_r.save_pretrained(UpperCamelCase__       ,legacy_format=UpperCamelCase__)
																						lowercase						     =						tokenizer_p.save_pretrained(UpperCamelCase__)

																						# Checks it saved the tokenizer.json file
																						self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files))

																						# Checks everything loads correctly in the same way
																						lowercase						     =						tokenizer_r.from_pretrained(UpperCamelCase__)
																						lowercase						     =						tokenizer_p.from_pretrained(UpperCamelCase__)

																						# Check special tokens are set accordingly on Rust and Python
																						for key in tokenizer_pp.special_tokens_map:
																											self.assertTrue(hasattr(UpperCamelCase__       ,UpperCamelCase__))

																						shutil.rmtree(UpperCamelCase__)







@require_torch
@require_sentencepiece
@require_tokenizers
class     lowercase		( unittest.TestCase		):
							lowercase_	:	List[str]	 ='''facebook/mbart-large-50-one-to-many-mmt'''
							lowercase_	:	int	 =[
							    ''' UN Chief Says There Is No Military Solution in Syria''',
							    ''' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.''',
							]
							lowercase_	:	Optional[Any]	 =[
							    '''Şeful ONU declară că nu există o soluţie militară în Siria''',
							    '''Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei'''
							    ''' pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor'''
							    ''' face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.''',
							]
							lowercase_	:	Dict	 =[EN_CODE, 8274, 127873, 25916, 7, 8622, 2071, 438, 67485, 53, 187895, 23, 51712, 2]




							@classmethod
							def 			A__				(    cls):
												lowercase						     =						MBartaaTokenizer.from_pretrained(
												    cls.checkpoint_name       ,src_lang='''en_XX'''       ,tgt_lang='''ro_RO''')
												lowercase						     =						1
												return cls




							def 			A__				(    self):
												self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ar_AR''']       ,2_5_0_0_0_1)
												self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''en_EN''']       ,2_5_0_0_0_4)
												self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ro_RO''']       ,2_5_0_0_2_0)
												self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''mr_IN''']       ,2_5_0_0_3_8)




							def 			A__				(    self):
												lowercase						     =						self.tokenizer.batch_encode_plus(self.src_text).input_ids[0]
												self.assertListEqual(self.expected_src_tokens       ,UpperCamelCase__)




							def 			A__				(    self):
												self.assertIn(UpperCamelCase__       ,self.tokenizer.all_special_ids)
												lowercase						     =						[RO_CODE, 8_8_4, 9_0_1_9, 9_6, 9, 9_1_6, 8_6_7_9_2, 3_6, 1_8_7_4_3, 1_5_5_9_6, 5, 2]
												lowercase						     =						self.tokenizer.decode(UpperCamelCase__       ,skip_special_tokens=UpperCamelCase__)
												lowercase						     =						self.tokenizer.decode(generated_ids[1:]       ,skip_special_tokens=UpperCamelCase__)
												self.assertEqual(UpperCamelCase__       ,UpperCamelCase__)
												self.assertNotIn(self.tokenizer.eos_token       ,UpperCamelCase__)




							def 			A__				(    self):
												lowercase						     =						['''this is gunna be a long sentence ''' * 2_0]
												assert isinstance(src_text[0]       ,UpperCamelCase__)
												lowercase						     =						1_0
												lowercase						     =						self.tokenizer(UpperCamelCase__       ,max_length=UpperCamelCase__       ,truncation=UpperCamelCase__).input_ids[0]
												self.assertEqual(ids[0]       ,UpperCamelCase__)
												self.assertEqual(ids[-1]       ,2)
												self.assertEqual(len(UpperCamelCase__)       ,UpperCamelCase__)




							def 			A__				(    self):
												self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR'''])       ,[2_5_0_0_5_3, 2_5_0_0_0_1])




							def 			A__				(    self):
												lowercase						     =						tempfile.mkdtemp()
												lowercase						     =						self.tokenizer.fairseq_tokens_to_ids
												self.tokenizer.save_pretrained(UpperCamelCase__)
												lowercase						     =						MBartaaTokenizer.from_pretrained(UpperCamelCase__)
												self.assertDictEqual(new_tok.fairseq_tokens_to_ids       ,UpperCamelCase__)




							@require_torch
							def 			A__				(    self):
												lowercase						     =						self.tokenizer(self.src_text       ,text_target=self.tgt_text       ,padding=UpperCamelCase__       ,return_tensors='''pt''')
												lowercase						     =						shift_tokens_right(batch['''labels''']       ,self.tokenizer.pad_token_id)

												# fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
												assert batch.input_ids[1][0] == EN_CODE
												assert batch.input_ids[1][-1] == 2
												assert batch.labels[1][0] == RO_CODE
												assert batch.labels[1][-1] == 2
												assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE]




							@require_torch
							def 			A__				(    self):
												lowercase						     =						self.tokenizer(
												    self.src_text       ,text_target=self.tgt_text       ,padding=UpperCamelCase__       ,truncation=UpperCamelCase__       ,max_length=len(self.expected_src_tokens)       ,return_tensors='''pt'''       ,)
												lowercase						     =						shift_tokens_right(batch['''labels''']       ,self.tokenizer.pad_token_id)

												self.assertIsInstance(UpperCamelCase__       ,UpperCamelCase__)

												self.assertEqual((2, 1_4)       ,batch.input_ids.shape)
												self.assertEqual((2, 1_4)       ,batch.attention_mask.shape)
												lowercase						     =						batch.input_ids.tolist()[0]
												self.assertListEqual(self.expected_src_tokens       ,UpperCamelCase__)
												self.assertEqual(2       ,batch.decoder_input_ids[0, 0])  # decoder_start_token_id
												# Test that special tokens are reset
												self.assertEqual(self.tokenizer.prefix_tokens       ,[EN_CODE])
												self.assertEqual(self.tokenizer.suffix_tokens       ,[self.tokenizer.eos_token_id])




							def 			A__				(    self):
												lowercase						     =						self.tokenizer(self.src_text       ,padding=UpperCamelCase__       ,truncation=UpperCamelCase__       ,max_length=3       ,return_tensors='''pt''')
												lowercase						     =						self.tokenizer(
												    text_target=self.tgt_text       ,padding=UpperCamelCase__       ,truncation=UpperCamelCase__       ,max_length=1_0       ,return_tensors='''pt''')
												lowercase						     =						targets['''input_ids''']
												lowercase						     =						shift_tokens_right(UpperCamelCase__       ,self.tokenizer.pad_token_id)

												self.assertEqual(batch.input_ids.shape[1]       ,3)
												self.assertEqual(batch.decoder_input_ids.shape[1]       ,1_0)





							@require_torch
							def 			A__				(    self):
												lowercase						     =						self.tokenizer._build_translation_inputs(
												    '''A test'''       ,return_tensors='''pt'''       ,src_lang='''en_XX'''       ,tgt_lang='''ar_AR''')

												self.assertEqual(
												    nested_simplify(UpperCamelCase__)       ,{
												        # en_XX, A, test, EOS
												        '''input_ids''': [[2_5_0_0_0_4, 6_2, 3_0_3_4, 2]],
												        '''attention_mask''': [[1, 1, 1, 1]],
												        # ar_AR
												        '''forced_bos_token_id''': 2_5_0_0_0_1,
												    }       ,)







from __future__ import annotations

from decimal import Decimal

from numpy import array



def 	UpperCamelCase   (							lowerCAmelCase__		):
					'''simple docstring'''
					lowercase						     =						Decimal

					# Check if the provided matrix has 2 rows and 2 columns
					# since this implementation only works for 2x2 matrices
					if len(lowerCAmelCase__		) == 2 and len(matrix[0]		) == 2 and len(matrix[1]		) == 2:
										# Calculate the determinant of the matrix
										lowercase						     =						float(
										    d(matrix[0][0]		) * d(matrix[1][1]		) - d(matrix[1][0]		) * d(matrix[0][1]		)		)
										if determinant == 0:
															raise ValueError('''This matrix has no inverse.'''		)

										# Creates a copy of the matrix with swapped positions of the elements
										lowercase						     =						[[0.0, 0.0], [0.0, 0.0]]
										lowercase     ,						lowercase						     =						matrix[1][1], matrix[0][0]
										lowercase     ,						lowercase						     =						-matrix[1][0], -matrix[0][1]

										# Calculate the inverse of the matrix
										return [
										    [(float(d(lowerCAmelCase__		)		) / determinant) or 0.0 for n in row] for row in swapped_matrix
										]
					elif (
					    len(lowerCAmelCase__		) == 3
					    and len(matrix[0]		) == 3
					    and len(matrix[1]		) == 3
					    and len(matrix[2]		) == 3
					):
										# Calculate the determinant of the matrix using Sarrus rule
										lowercase						     =						float(
										    (
										        (d(matrix[0][0]		) * d(matrix[1][1]		) * d(matrix[2][2]		))
										        + (d(matrix[0][1]		) * d(matrix[1][2]		) * d(matrix[2][0]		))
										        + (d(matrix[0][2]		) * d(matrix[1][0]		) * d(matrix[2][1]		))
										    )
										    - (
										        (d(matrix[0][2]		) * d(matrix[1][1]		) * d(matrix[2][0]		))
										        + (d(matrix[0][1]		) * d(matrix[1][0]		) * d(matrix[2][2]		))
										        + (d(matrix[0][0]		) * d(matrix[1][2]		) * d(matrix[2][1]		))
										    )		)
										if determinant == 0:
															raise ValueError('''This matrix has no inverse.'''		)

										# Creating cofactor matrix
										lowercase						     =						[
										    [d(0.0		), d(0.0		), d(0.0		)],
										    [d(0.0		), d(0.0		), d(0.0		)],
										    [d(0.0		), d(0.0		), d(0.0		)],
										]
										lowercase						     =						(d(matrix[1][1]		) * d(matrix[2][2]		)) - (
										    d(matrix[1][2]		) * d(matrix[2][1]		)
										)
										lowercase						     =						-(
										    (d(matrix[1][0]		) * d(matrix[2][2]		)) - (d(matrix[1][2]		) * d(matrix[2][0]		))
										)
										lowercase						     =						(d(matrix[1][0]		) * d(matrix[2][1]		)) - (
										    d(matrix[1][1]		) * d(matrix[2][0]		)
										)
										lowercase						     =						-(
										    (d(matrix[0][1]		) * d(matrix[2][2]		)) - (d(matrix[0][2]		) * d(matrix[2][1]		))
										)
										lowercase						     =						(d(matrix[0][0]		) * d(matrix[2][2]		)) - (
										    d(matrix[0][2]		) * d(matrix[2][0]		)
										)
										lowercase						     =						-(
										    (d(matrix[0][0]		) * d(matrix[2][1]		)) - (d(matrix[0][1]		) * d(matrix[2][0]		))
										)
										lowercase						     =						(d(matrix[0][1]		) * d(matrix[1][2]		)) - (
										    d(matrix[0][2]		) * d(matrix[1][1]		)
										)
										lowercase						     =						-(
										    (d(matrix[0][0]		) * d(matrix[1][2]		)) - (d(matrix[0][2]		) * d(matrix[1][0]		))
										)
										lowercase						     =						(d(matrix[0][0]		) * d(matrix[1][1]		)) - (
										    d(matrix[0][1]		) * d(matrix[1][0]		)
										)

										# Transpose the cofactor matrix (Adjoint matrix)
										lowercase						     =						array(lowerCAmelCase__		)
										for i in range(3		):
															for j in range(3		):
																				lowercase						     =						cofactor_matrix[j][i]

        # Inverse of the matrix using the formula (1/determinant) * adjoint matrix
										lowercase						     =						array(lowerCAmelCase__		)
										for i in range(3		):
															for j in range(3		):
																				inverse_matrix[i][j] /= d(lowerCAmelCase__		)

        # Calculate the inverse of the matrix
										return [[float(d(lowerCAmelCase__		)		) or 0.0 for n in row] for row in inverse_matrix]
					raise ValueError('''Please provide a matrix of size 2x2 or 3x3.'''		)




