


'''simple docstring'''






from __future__ import annotations

from decimal import Decimal

from numpy import array







def     UpperCamelCase_      (   A__ :       list[list[float]] ):
  '''simple docstring'''





  lowerCAmelCase_      :				List[str]      =       Decimal

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

    # Calculate the inverse of the matrix
    return [
        [(float(d(A__ ) ) / determinant) or 0.0 for n in row] for row in swapped_matrix
    ]
  elif (
      len(A__ ) == 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_      :				Any      =       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_      :				str      =       [
        [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_      :				str      =       (d(matrix[1][1] ) * d(matrix[2][2] )) - (
        d(matrix[1][2] ) * d(matrix[2][1] )
    )
    lowerCAmelCase_      :				Dict      =       -(
        (d(matrix[1][0] ) * d(matrix[2][2] )) - (d(matrix[1][2] ) * d(matrix[2][0] ))
    )
    lowerCAmelCase_      :				Any      =       (d(matrix[1][0] ) * d(matrix[2][1] )) - (
        d(matrix[1][1] ) * d(matrix[2][0] )
    )
    lowerCAmelCase_      :				List[Any]      =       -(
        (d(matrix[0][1] ) * d(matrix[2][2] )) - (d(matrix[0][2] ) * d(matrix[2][1] ))
    )
    lowerCAmelCase_      :				Tuple      =       (d(matrix[0][0] ) * d(matrix[2][2] )) - (
        d(matrix[0][2] ) * d(matrix[2][0] )
    )
    lowerCAmelCase_      :				Any      =       -(
        (d(matrix[0][0] ) * d(matrix[2][1] )) - (d(matrix[0][1] ) * d(matrix[2][0] ))
    )
    lowerCAmelCase_      :				Optional[Any]      =       (d(matrix[0][1] ) * d(matrix[1][2] )) - (
        d(matrix[0][2] ) * d(matrix[1][1] )
    )
    lowerCAmelCase_      :				List[Any]      =       -(
        (d(matrix[0][0] ) * d(matrix[1][2] )) - (d(matrix[0][2] ) * d(matrix[1][0] ))
    )
    lowerCAmelCase_      :				Tuple      =       (d(matrix[0][0] ) * d(matrix[1][1] )) - (
        d(matrix[0][1] ) * d(matrix[1][0] )
    )

    # Transpose the cofactor matrix (Adjoint matrix)
    lowerCAmelCase_      :				List[Any]      =       array(A__ )
    for i in range(3 ):
      for j in range(3 ):
        lowerCAmelCase_      :				Union[str, Any]      =       cofactor_matrix[j][i]

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

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










'''simple docstring'''






import unittest

from diffusers.pipelines.pipeline_utils import is_safetensors_compatible






class        __snake_case	(       unittest.TestCase):







    """simple docstring"""



    def __lowercase       (       self   :  Tuple		)       ->  Dict:
      lowerCAmelCase_      :				str      =       [
          """safety_checker/pytorch_model.bin""",
          """safety_checker/model.safetensors""",
          """vae/diffusion_pytorch_model.bin""",
          """vae/diffusion_pytorch_model.safetensors""",
          """text_encoder/pytorch_model.bin""",
          """text_encoder/model.safetensors""",
          """unet/diffusion_pytorch_model.bin""",
          """unet/diffusion_pytorch_model.safetensors""",
      ]
      self.assertTrue(is_safetensors_compatible(lowerCamelCase		)		)

    def __lowercase       (       self   :  List[Any]		)       ->  int:
      lowerCAmelCase_      :				Tuple      =       [
          """unet/diffusion_pytorch_model.bin""",
          """unet/diffusion_pytorch_model.safetensors""",
      ]
      self.assertTrue(is_safetensors_compatible(lowerCamelCase		)		)

    def __lowercase       (       self   :  Optional[int]		)       ->  Optional[Any]:
      lowerCAmelCase_      :				int      =       [
          """safety_checker/pytorch_model.bin""",
          """safety_checker/model.safetensors""",
          """vae/diffusion_pytorch_model.bin""",
          """vae/diffusion_pytorch_model.safetensors""",
          """text_encoder/pytorch_model.bin""",
          """text_encoder/model.safetensors""",
          """unet/diffusion_pytorch_model.bin""",
          # Removed: 'unet/diffusion_pytorch_model.safetensors',
      ]
      self.assertFalse(is_safetensors_compatible(lowerCamelCase		)		)

    def __lowercase       (       self   :  int		)       ->  List[Any]:
      lowerCAmelCase_      :				Dict      =       [
          """text_encoder/pytorch_model.bin""",
          """text_encoder/model.safetensors""",
      ]
      self.assertTrue(is_safetensors_compatible(lowerCamelCase		)		)

    def __lowercase       (       self   :  str		)       ->  List[str]:
      lowerCAmelCase_      :				Union[str, Any]      =       [
          """safety_checker/pytorch_model.bin""",
          """safety_checker/model.safetensors""",
          """vae/diffusion_pytorch_model.bin""",
          """vae/diffusion_pytorch_model.safetensors""",
          """text_encoder/pytorch_model.bin""",
          # Removed: 'text_encoder/model.safetensors',
          """unet/diffusion_pytorch_model.bin""",
          """unet/diffusion_pytorch_model.safetensors""",
      ]
      self.assertFalse(is_safetensors_compatible(lowerCamelCase		)		)

    def __lowercase       (       self   :  List[Any]		)       ->  Tuple:
      lowerCAmelCase_      :				Union[str, Any]      =       [
          """safety_checker/pytorch_model.fp16.bin""",
          """safety_checker/model.fp16.safetensors""",
          """vae/diffusion_pytorch_model.fp16.bin""",
          """vae/diffusion_pytorch_model.fp16.safetensors""",
          """text_encoder/pytorch_model.fp16.bin""",
          """text_encoder/model.fp16.safetensors""",
          """unet/diffusion_pytorch_model.fp16.bin""",
          """unet/diffusion_pytorch_model.fp16.safetensors""",
      ]
      lowerCAmelCase_      :				Union[str, Any]      =       """fp16"""
      self.assertTrue(is_safetensors_compatible(lowerCamelCase   ,						variant=lowerCamelCase		)		)

    def __lowercase       (       self   :  Optional[Any]		)       ->  List[str]:
      lowerCAmelCase_      :				str      =       [
          """unet/diffusion_pytorch_model.fp16.bin""",
          """unet/diffusion_pytorch_model.fp16.safetensors""",
      ]
      lowerCAmelCase_      :				Optional[int]      =       """fp16"""
      self.assertTrue(is_safetensors_compatible(lowerCamelCase   ,						variant=lowerCamelCase		)		)

    def __lowercase       (       self   :  Tuple		)       ->  Optional[Any]:
      # pass variant but use the non-variant filenames
      lowerCAmelCase_      :				Dict      =       [
          """unet/diffusion_pytorch_model.bin""",
          """unet/diffusion_pytorch_model.safetensors""",
      ]
      lowerCAmelCase_      :				str      =       """fp16"""
      self.assertTrue(is_safetensors_compatible(lowerCamelCase   ,						variant=lowerCamelCase		)		)

    def __lowercase       (       self   :  Optional[int]		)       ->  List[str]:
      lowerCAmelCase_      :				str      =       [
          """safety_checker/pytorch_model.fp16.bin""",
          """safety_checker/model.fp16.safetensors""",
          """vae/diffusion_pytorch_model.fp16.bin""",
          """vae/diffusion_pytorch_model.fp16.safetensors""",
          """text_encoder/pytorch_model.fp16.bin""",
          """text_encoder/model.fp16.safetensors""",
          """unet/diffusion_pytorch_model.fp16.bin""",
          # Removed: 'unet/diffusion_pytorch_model.fp16.safetensors',
      ]
      lowerCAmelCase_      :				List[str]      =       """fp16"""
      self.assertFalse(is_safetensors_compatible(lowerCamelCase   ,						variant=lowerCamelCase		)		)

    def __lowercase       (       self   :  Union[str, Any]		)       ->  Optional[int]:
      lowerCAmelCase_      :				str      =       [
          """text_encoder/pytorch_model.fp16.bin""",
          """text_encoder/model.fp16.safetensors""",
      ]
      lowerCAmelCase_      :				Optional[Any]      =       """fp16"""
      self.assertTrue(is_safetensors_compatible(lowerCamelCase   ,						variant=lowerCamelCase		)		)

    def __lowercase       (       self   :  List[Any]		)       ->  List[Any]:
      # pass variant but use the non-variant filenames
      lowerCAmelCase_      :				Dict      =       [
          """text_encoder/pytorch_model.bin""",
          """text_encoder/model.safetensors""",
      ]
      lowerCAmelCase_      :				Any      =       """fp16"""
      self.assertTrue(is_safetensors_compatible(lowerCamelCase   ,						variant=lowerCamelCase		)		)





    def __lowercase       (       self   :  Dict		)       ->  Any:
      lowerCAmelCase_      :				Optional[int]      =       [
          """safety_checker/pytorch_model.fp16.bin""",
          """safety_checker/model.fp16.safetensors""",
          """vae/diffusion_pytorch_model.fp16.bin""",
          """vae/diffusion_pytorch_model.fp16.safetensors""",
          """text_encoder/pytorch_model.fp16.bin""",
          # 'text_encoder/model.fp16.safetensors',
          """unet/diffusion_pytorch_model.fp16.bin""",
          """unet/diffusion_pytorch_model.fp16.safetensors""",
      ]
      lowerCAmelCase_      :				int      =       """fp16"""
      self.assertFalse(is_safetensors_compatible(lowerCamelCase   ,						variant=lowerCamelCase		)		)



