


'''simple docstring'''






from __future__ import annotations

from decimal import Decimal

from numpy import array






def 		_A			(lowerCAmelCase__					:list[list[float]]						)				->					list[list[float]]:




     '''simple docstring'''



     _a      =							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
          _a      =							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
          _a      =							[[0.0, 0.0], [0.0, 0.0]]
          _a ,				_a      =							matrix[1][1], matrix[0][0]
          _a ,				_a      =							-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
          _a      =							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
          _a      =							[
              [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						)],
          ]
          _a      =							(d(matrix[1][1]						) * d(matrix[2][2]						)) - (
              d(matrix[1][2]						) * d(matrix[2][1]						)
          )
          _a      =							-(
              (d(matrix[1][0]						) * d(matrix[2][2]						)) - (d(matrix[1][2]						) * d(matrix[2][0]						))
          )
          _a      =							(d(matrix[1][0]						) * d(matrix[2][1]						)) - (
              d(matrix[1][1]						) * d(matrix[2][0]						)
          )
          _a      =							-(
              (d(matrix[0][1]						) * d(matrix[2][2]						)) - (d(matrix[0][2]						) * d(matrix[2][1]						))
          )
          _a      =							(d(matrix[0][0]						) * d(matrix[2][2]						)) - (
              d(matrix[0][2]						) * d(matrix[2][0]						)
          )
          _a      =							-(
              (d(matrix[0][0]						) * d(matrix[2][1]						)) - (d(matrix[0][1]						) * d(matrix[2][0]						))
          )
          _a      =							(d(matrix[0][1]						) * d(matrix[1][2]						)) - (
              d(matrix[0][2]						) * d(matrix[1][1]						)
          )
          _a      =							-(
              (d(matrix[0][0]						) * d(matrix[1][2]						)) - (d(matrix[0][2]						) * d(matrix[1][0]						))
          )
          _a      =							(d(matrix[0][0]						) * d(matrix[1][1]						)) - (
              d(matrix[0][1]						) * d(matrix[1][0]						)
          )

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

        # Inverse of the matrix using the formula (1/determinant) * adjoint matrix
          _a      =							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.'						)





'''simple docstring'''






import unittest

from diffusers.pipelines.pipeline_utils import is_safetensors_compatible




class 	a       (       unittest.TestCase    ):
 def 							__UpperCAmelCase						(	self  )   ->							int:
      _a      =							[
          '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(__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      _a      =							[
          'unet/diffusion_pytorch_model.bin',
          'unet/diffusion_pytorch_model.safetensors',
      ]
      self.assertTrue(is_safetensors_compatible(__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							Optional[int]:
      _a      =							[
          '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(__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							Optional[Any]:
      _a      =							[
          'text_encoder/pytorch_model.bin',
          'text_encoder/model.safetensors',
      ]
      self.assertTrue(is_safetensors_compatible(__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							str:
      _a      =							[
          '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(__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							List[Any]:
      _a      =							[
          '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',
      ]
      _a      =							'fp16'
      self.assertTrue(is_safetensors_compatible(__magic_name__ ,			variant=__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							Any:
      _a      =							[
          'unet/diffusion_pytorch_model.fp16.bin',
          'unet/diffusion_pytorch_model.fp16.safetensors',
      ]
      _a      =							'fp16'
      self.assertTrue(is_safetensors_compatible(__magic_name__ ,			variant=__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							int:
      # pass variant but use the non-variant filenames
      _a      =							[
          'unet/diffusion_pytorch_model.bin',
          'unet/diffusion_pytorch_model.safetensors',
      ]
      _a      =							'fp16'
      self.assertTrue(is_safetensors_compatible(__magic_name__ ,			variant=__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							List[str]:
      _a      =							[
          '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',
      ]
      _a      =							'fp16'
      self.assertFalse(is_safetensors_compatible(__magic_name__ ,			variant=__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							Union[str, Any]:
      _a      =							[
          'text_encoder/pytorch_model.fp16.bin',
          'text_encoder/model.fp16.safetensors',
      ]
      _a      =							'fp16'
      self.assertTrue(is_safetensors_compatible(__magic_name__ ,			variant=__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							List[Any]:
      # pass variant but use the non-variant filenames
      _a      =							[
          'text_encoder/pytorch_model.bin',
          'text_encoder/model.safetensors',
      ]
      _a      =							'fp16'
      self.assertTrue(is_safetensors_compatible(__magic_name__ ,			variant=__magic_name__  )  )




 def 							__UpperCAmelCase						(	self  )   ->							List[Any]:
      _a      =							[
          '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',
      ]
      _a      =							'fp16'
      self.assertFalse(is_safetensors_compatible(__magic_name__ ,			variant=__magic_name__  )  )

