






import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
UpperCamelCase								=		logging.get_logger(__name__)






def    __magic_name__    (	SCREAMING_SNAKE_CASE				)     ->    List[Any]:
							_lowercase							:   Optional[Any] 							=   SwinConfig(
							    embed_dim=192     ,     depths=(2, 2, 18, 2)     ,     num_heads=(6, 12, 24, 48)     ,     window_size=12     ,     out_features=['stage2', 'stage3', 'stage4']     ,     )

							_lowercase							:   Any 							=   DetaConfig(
							    backbone_config=SCREAMING_SNAKE_CASE     ,     num_queries=900     ,     encoder_ffn_dim=2_048     ,     decoder_ffn_dim=2_048     ,     num_feature_levels=5     ,     assign_first_stage=SCREAMING_SNAKE_CASE     ,     with_box_refine=SCREAMING_SNAKE_CASE     ,     two_stage=SCREAMING_SNAKE_CASE     ,     )

							# set labels
							_lowercase							:   int 							=   'huggingface/label-files'
							if "o365" in model_name:
														_lowercase							:   Any 							=   366
														_lowercase							:   Dict 							=   'object365-id2label.json'
							else:
														_lowercase							:   str 							=   91
														_lowercase							:   Union[str, Any] 							=   'coco-detection-id2label.json'

							_lowercase							:   Optional[int] 							=   num_labels
							_lowercase							:   Dict 							=   json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     repo_type='dataset'				)				)     ,     'r'				)				)
							_lowercase							:   List[str] 							=   {int(SCREAMING_SNAKE_CASE				): v for k, v in idalabel.items()}
							_lowercase							:   Any 							=   idalabel
							_lowercase							:   Union[str, Any] 							=   {v: k for k, v in idalabel.items()}

							return config






def    __magic_name__    (	SCREAMING_SNAKE_CASE				)     ->    Union[str, Any]:
							_lowercase							:   Union[str, Any] 							=   []

							# stem
							# fmt: off
							rename_keys.append(('backbone.0.body.patch_embed.proj.weight', 'model.backbone.model.embeddings.patch_embeddings.projection.weight')				)
							rename_keys.append(('backbone.0.body.patch_embed.proj.bias', 'model.backbone.model.embeddings.patch_embeddings.projection.bias')				)
							rename_keys.append(('backbone.0.body.patch_embed.norm.weight', 'model.backbone.model.embeddings.norm.weight')				)
							rename_keys.append(('backbone.0.body.patch_embed.norm.bias', 'model.backbone.model.embeddings.norm.bias')				)
							# stages
							for i in range(len(config.backbone_config.depths				)				):
														for j in range(config.backbone_config.depths[i]				):
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm1.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm1.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm2.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm2.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias""")				)

														if i < 3:
																					rename_keys.append((F"""backbone.0.body.layers.{i}.downsample.reduction.weight""", F"""model.backbone.model.encoder.layers.{i}.downsample.reduction.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.downsample.norm.weight""", F"""model.backbone.model.encoder.layers.{i}.downsample.norm.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.downsample.norm.bias""", F"""model.backbone.model.encoder.layers.{i}.downsample.norm.bias""")				)

							rename_keys.append(('backbone.0.body.norm1.weight', 'model.backbone.model.hidden_states_norms.stage2.weight')				)
							rename_keys.append(('backbone.0.body.norm1.bias', 'model.backbone.model.hidden_states_norms.stage2.bias')				)
							rename_keys.append(('backbone.0.body.norm2.weight', 'model.backbone.model.hidden_states_norms.stage3.weight')				)
							rename_keys.append(('backbone.0.body.norm2.bias', 'model.backbone.model.hidden_states_norms.stage3.bias')				)
							rename_keys.append(('backbone.0.body.norm3.weight', 'model.backbone.model.hidden_states_norms.stage4.weight')				)
							rename_keys.append(('backbone.0.body.norm3.bias', 'model.backbone.model.hidden_states_norms.stage4.bias')				)

							# transformer encoder
							for i in range(config.encoder_layers				):
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight""", F"""model.encoder.layers.{i}.self_attn.sampling_offsets.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias""", F"""model.encoder.layers.{i}.self_attn.sampling_offsets.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.attention_weights.weight""", F"""model.encoder.layers.{i}.self_attn.attention_weights.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.attention_weights.bias""", F"""model.encoder.layers.{i}.self_attn.attention_weights.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.value_proj.weight""", F"""model.encoder.layers.{i}.self_attn.value_proj.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.value_proj.bias""", F"""model.encoder.layers.{i}.self_attn.value_proj.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.output_proj.weight""", F"""model.encoder.layers.{i}.self_attn.output_proj.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.output_proj.bias""", F"""model.encoder.layers.{i}.self_attn.output_proj.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.norm1.weight""", F"""model.encoder.layers.{i}.self_attn_layer_norm.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.norm1.bias""", F"""model.encoder.layers.{i}.self_attn_layer_norm.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.weight""", F"""model.encoder.layers.{i}.fc1.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.bias""", F"""model.encoder.layers.{i}.fc1.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.weight""", F"""model.encoder.layers.{i}.fc2.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.bias""", F"""model.encoder.layers.{i}.fc2.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.weight""", F"""model.encoder.layers.{i}.final_layer_norm.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.bias""", F"""model.encoder.layers.{i}.final_layer_norm.bias""")				)

							# transformer decoder
							for i in range(config.decoder_layers				):
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight""", F"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias""", F"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.attention_weights.weight""", F"""model.decoder.layers.{i}.encoder_attn.attention_weights.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.attention_weights.bias""", F"""model.decoder.layers.{i}.encoder_attn.attention_weights.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.value_proj.weight""", F"""model.decoder.layers.{i}.encoder_attn.value_proj.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.value_proj.bias""", F"""model.decoder.layers.{i}.encoder_attn.value_proj.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.output_proj.weight""", F"""model.decoder.layers.{i}.encoder_attn.output_proj.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.output_proj.bias""", F"""model.decoder.layers.{i}.encoder_attn.output_proj.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.norm1.weight""", F"""model.decoder.layers.{i}.encoder_attn_layer_norm.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.norm1.bias""", F"""model.decoder.layers.{i}.encoder_attn_layer_norm.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", F"""model.decoder.layers.{i}.self_attn.out_proj.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", F"""model.decoder.layers.{i}.self_attn.out_proj.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.norm2.weight""", F"""model.decoder.layers.{i}.self_attn_layer_norm.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.norm2.bias""", F"""model.decoder.layers.{i}.self_attn_layer_norm.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.weight""", F"""model.decoder.layers.{i}.fc1.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.bias""", F"""model.decoder.layers.{i}.fc1.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.weight""", F"""model.decoder.layers.{i}.fc2.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.bias""", F"""model.decoder.layers.{i}.fc2.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.weight""", F"""model.decoder.layers.{i}.final_layer_norm.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.bias""", F"""model.decoder.layers.{i}.final_layer_norm.bias""")				)

							# fmt: on

							return rename_keys






def    __magic_name__    (	SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)     ->    List[str]:
							_lowercase							:   Any 							=   dct.pop(SCREAMING_SNAKE_CASE				)
							_lowercase							:   List[str] 							=   val






def    __magic_name__    (	SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)     ->    Union[str, Any]:
							_lowercase							:   Optional[Any] 							=   [int(backbone_config.embed_dim * 2**i				) for i in range(len(backbone_config.depths				)				)]
							for i in range(len(backbone_config.depths				)				):
														_lowercase							:   Union[str, Any] 							=   num_features[i]
														for j in range(backbone_config.depths[i]				):
																					# fmt: off
																					# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
																					_lowercase							:   str 							=   state_dict.pop(F"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight"""				)
																					_lowercase							:   Optional[Any] 							=   state_dict.pop(F"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias"""				)
																					# next, add query, keys and values (in that order) to the state dict
																					_lowercase							:   List[str] 							=   in_proj_weight[:dim, :]
																					_lowercase							:   List[str] 							=   in_proj_bias[: dim]
																					_lowercase							:   str 							=   in_proj_weight[
																					    dim : dim * 2, :
																					]
																					_lowercase							:   Union[str, Any] 							=   in_proj_bias[
																					    dim : dim * 2
																					]
																					_lowercase							:   Dict 							=   in_proj_weight[
																					    -dim :, :
																					]
																					_lowercase							:   Union[str, Any] 							=   in_proj_bias[-dim :]
																					# fmt: on






def    __magic_name__    (	SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)     ->    Optional[Any]:
							# transformer decoder self-attention layers
							_lowercase							:   str 							=   config.d_model
							for i in range(config.decoder_layers				):
														# read in weights + bias of input projection layer of self-attention
														_lowercase							:   Dict 							=   state_dict.pop(F"""transformer.decoder.layers.{i}.self_attn.in_proj_weight"""				)
														_lowercase							:   str 							=   state_dict.pop(F"""transformer.decoder.layers.{i}.self_attn.in_proj_bias"""				)
														# next, add query, keys and values (in that order) to the state dict
														_lowercase							:   List[Any] 							=   in_proj_weight[:hidden_size, :]
														_lowercase							:   Optional[Any] 							=   in_proj_bias[:hidden_size]
														_lowercase							:   List[str] 							=   in_proj_weight[
														    hidden_size : hidden_size * 2, :
														]
														_lowercase							:   str 							=   in_proj_bias[hidden_size : hidden_size * 2]
														_lowercase							:   str 							=   in_proj_weight[-hidden_size:, :]
														_lowercase							:   Dict 							=   in_proj_bias[-hidden_size:]






def    __magic_name__    (	)     ->    Optional[int]:
							_lowercase							:   str 							=   'http://images.cocodataset.org/val2017/000000039769.jpg'
							_lowercase							:   List[Any] 							=   Image.open(requests.get(SCREAMING_SNAKE_CASE     ,     stream=SCREAMING_SNAKE_CASE				).raw				)

							return im






@torch.no_grad()
def    __magic_name__    (	SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)     ->    Optional[Any]:
							_lowercase							:   Dict 							=   get_deta_config(SCREAMING_SNAKE_CASE				)

							# load original state dict
							if model_name == "deta-swin-large":
														_lowercase							:   int 							=   hf_hub_download(repo_id='nielsr/deta-checkpoints'     ,     filename='adet_swin_ft.pth'				)
							elif model_name == "deta-swin-large-o365":
														_lowercase							:   Dict 							=   hf_hub_download(repo_id='jozhang97/deta-swin-l-o365'     ,     filename='deta_swin_pt_o365.pth'				)
							else:
														raise ValueError(F"""Model name {model_name} not supported"""				)

							_lowercase							:   str 							=   torch.load(SCREAMING_SNAKE_CASE     ,     map_location='cpu'				)['model']

							# original state dict
							for name, param in state_dict.items():
														print(SCREAMING_SNAKE_CASE     ,     param.shape				)

							# rename keys
							_lowercase							:   Tuple 							=   create_rename_keys(SCREAMING_SNAKE_CASE				)
							for src, dest in rename_keys:
														rename_key(SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)
							read_in_swin_q_k_v(SCREAMING_SNAKE_CASE     ,     config.backbone_config				)
							read_in_decoder_q_k_v(SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)

							# fix some prefixes
							for key in state_dict.copy().keys():
														if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
																					_lowercase							:   int 							=   state_dict.pop(SCREAMING_SNAKE_CASE				)
																					_lowercase							:   List[str] 							=   val
														if "input_proj" in key:
																					_lowercase							:   Any 							=   state_dict.pop(SCREAMING_SNAKE_CASE				)
																					_lowercase							:   int 							=   val
														if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
																					_lowercase							:   Union[str, Any] 							=   state_dict.pop(SCREAMING_SNAKE_CASE				)
																					_lowercase							:   Dict 							=   val

    # finally, create HuggingFace model and load state dict
							_lowercase							:   Optional[Any] 							=   DetaForObjectDetection(SCREAMING_SNAKE_CASE				)
							model.load_state_dict(SCREAMING_SNAKE_CASE				)
							model.eval()

							_lowercase							:   Tuple 							=   'cuda' if torch.cuda.is_available() else 'cpu'
							model.to(SCREAMING_SNAKE_CASE				)

							# load image processor
							_lowercase							:   Optional[int] 							=   DetaImageProcessor(format='coco_detection'				)

							# verify our conversion on image
							_lowercase							:   int 							=   prepare_img()
							_lowercase							:   Tuple 							=   processor(images=SCREAMING_SNAKE_CASE     ,     return_tensors='pt'				)
							_lowercase							:   Union[str, Any] 							=   encoding['pixel_values']
							_lowercase							:   Any 							=   model(pixel_values.to(SCREAMING_SNAKE_CASE				)				)

							# verify logits
							print('Logits:'     ,     outputs.logits[0, :3, :3]				)
							print('Boxes:'     ,     outputs.pred_boxes[0, :3, :3]				)
							if model_name == "deta-swin-large":
														_lowercase							:   Tuple 							=   torch.tensor(
														    [[-7.6308, -2.8485, -5.3737], [-7.2037, -4.5505, -4.8027], [-7.2943, -4.2611, -4.6617]]				)
														_lowercase							:   Dict 							=   torch.tensor([[0.4987, 0.4969, 0.9999], [0.2549, 0.5498, 0.4805], [0.5498, 0.2757, 0.0569]]				)
							elif model_name == "deta-swin-large-o365":
														_lowercase							:   Union[str, Any] 							=   torch.tensor(
														    [[-8.0122, -3.5720, -4.9717], [-8.1547, -3.6886, -4.6389], [-7.6610, -3.6194, -5.0134]]				)
														_lowercase							:   Dict 							=   torch.tensor([[0.2523, 0.5549, 0.4881], [0.7715, 0.4149, 0.4601], [0.5503, 0.2753, 0.0575]]				)
							assert torch.allclose(outputs.logits[0, :3, :3]     ,     expected_logits.to(SCREAMING_SNAKE_CASE				)     ,     atol=1E-4				)
							assert torch.allclose(outputs.pred_boxes[0, :3, :3]     ,     expected_boxes.to(SCREAMING_SNAKE_CASE				)     ,     atol=1E-4				)
							print('Everything ok!'				)

							if pytorch_dump_folder_path:
														# Save model and processor
														logger.info(F"""Saving PyTorch model and processor to {pytorch_dump_folder_path}..."""				)
														Path(SCREAMING_SNAKE_CASE				).mkdir(exist_ok=SCREAMING_SNAKE_CASE				)
														model.save_pretrained(SCREAMING_SNAKE_CASE				)
														processor.save_pretrained(SCREAMING_SNAKE_CASE				)

							# Push to hub
							if push_to_hub:
														print('Pushing model and processor to hub...'				)
														model.push_to_hub(F"""jozhang97/{model_name}"""				)
														processor.push_to_hub(F"""jozhang97/{model_name}"""				)


if __name__ == "__main__":
							UpperCamelCase								=		argparse.ArgumentParser()

							parser.add_argument(
							    "--model_name",
							    type=str,
							    default="deta-swin-large",
							    choices=["deta-swin-large", "deta-swin-large-o365"],
							    help="Name of the model you'd like to convert.",
							)
							parser.add_argument(
							    "--pytorch_dump_folder_path",
							    default=None,
							    type=str,
							    help="Path to the folder to output PyTorch model.",
							)
							parser.add_argument(
							    "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
							)
							UpperCamelCase								=		parser.parse_args()
							convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)










"""simple docstring"""




from __future__ import annotations

from decimal import Decimal

from numpy import array



def        a__					(							snake_case__							)		->   list[list[float]]:
			lowerCamelCase      =   Decimal

			# Check if the provided matrix has 2 rows and 2 columns
			# since this implementation only works for 2x2 matrices
			if len(snake_case__							) == 2 and len(matrix[0]							) == 2 and len(matrix[1]							) == 2:
						# Calculate the determinant of the matrix
						lowerCamelCase      =   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
						lowerCamelCase      =   [[0.0, 0.0], [0.0, 0.0]]
						lowerCamelCase ,  lowerCamelCase      =   matrix[1][1], matrix[0][0]
						lowerCamelCase ,  lowerCamelCase      =   -matrix[1][0], -matrix[0][1]

						# Calculate the inverse of the matrix
						return [
						    [(float(d(snake_case__							)							) / determinant) or 0.0 for n in row] for row in swapped_matrix
						]
			elif (
			    len(snake_case__							) == 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
						lowerCamelCase      =   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
						lowerCamelCase      =   [
						    [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							)],
						]
						lowerCamelCase      =   (d(matrix[1][1]							) * d(matrix[2][2]							)) - (
						    d(matrix[1][2]							) * d(matrix[2][1]							)
						)
						lowerCamelCase      =   -(
						    (d(matrix[1][0]							) * d(matrix[2][2]							)) - (d(matrix[1][2]							) * d(matrix[2][0]							))
						)
						lowerCamelCase      =   (d(matrix[1][0]							) * d(matrix[2][1]							)) - (
						    d(matrix[1][1]							) * d(matrix[2][0]							)
						)
						lowerCamelCase      =   -(
						    (d(matrix[0][1]							) * d(matrix[2][2]							)) - (d(matrix[0][2]							) * d(matrix[2][1]							))
						)
						lowerCamelCase      =   (d(matrix[0][0]							) * d(matrix[2][2]							)) - (
						    d(matrix[0][2]							) * d(matrix[2][0]							)
						)
						lowerCamelCase      =   -(
						    (d(matrix[0][0]							) * d(matrix[2][1]							)) - (d(matrix[0][1]							) * d(matrix[2][0]							))
						)
						lowerCamelCase      =   (d(matrix[0][1]							) * d(matrix[1][2]							)) - (
						    d(matrix[0][2]							) * d(matrix[1][1]							)
						)
						lowerCamelCase      =   -(
						    (d(matrix[0][0]							) * d(matrix[1][2]							)) - (d(matrix[0][2]							) * d(matrix[1][0]							))
						)
						lowerCamelCase      =   (d(matrix[0][0]							) * d(matrix[1][1]							)) - (
						    d(matrix[0][1]							) * d(matrix[1][0]							)
						)

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

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

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



