


import unittest

from diffusers.pipelines.pipeline_utils import is_safetensors_compatible







class 		_snake_case  (      unittest.TestCase							):




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						: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''',
           '''unet/diffusion_pytorch_model.safetensors''',
       ]
       self.assertTrue(is_safetensors_compatible(_lowerCamelCase    )    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:str 							=       [
           '''unet/diffusion_pytorch_model.bin''',
           '''unet/diffusion_pytorch_model.safetensors''',
       ]
       self.assertTrue(is_safetensors_compatible(_lowerCamelCase    )    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:Tuple 							=       [
           '''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        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:Union[str, Any] 							=       [
           '''text_encoder/pytorch_model.bin''',
           '''text_encoder/model.safetensors''',
       ]
       self.assertTrue(is_safetensors_compatible(_lowerCamelCase    )    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:Dict 							=       [
           '''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        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:Optional[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''',
       ]
       a						:Optional[int] 							=       '''fp16'''
       self.assertTrue(is_safetensors_compatible(_lowerCamelCase					,  variant=_lowerCamelCase    )    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:Any 							=       [
           '''unet/diffusion_pytorch_model.fp16.bin''',
           '''unet/diffusion_pytorch_model.fp16.safetensors''',
       ]
       a						:List[Any] 							=       '''fp16'''
       self.assertTrue(is_safetensors_compatible(_lowerCamelCase					,  variant=_lowerCamelCase    )    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       # pass variant but use the non-variant filenames
       a						:List[str] 							=       [
           '''unet/diffusion_pytorch_model.bin''',
           '''unet/diffusion_pytorch_model.safetensors''',
       ]
       a						:Optional[int] 							=       '''fp16'''
       self.assertTrue(is_safetensors_compatible(_lowerCamelCase					,  variant=_lowerCamelCase    )    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						: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''',
           # Removed: 'unet/diffusion_pytorch_model.fp16.safetensors',
       ]
       a						:List[str] 							=       '''fp16'''
       self.assertFalse(is_safetensors_compatible(_lowerCamelCase					,  variant=_lowerCamelCase    )    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:List[Any] 							=       [
           '''text_encoder/pytorch_model.fp16.bin''',
           '''text_encoder/model.fp16.safetensors''',
       ]
       a						:Any 							=       '''fp16'''
       self.assertTrue(is_safetensors_compatible(_lowerCamelCase					,  variant=_lowerCamelCase    )    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       # pass variant but use the non-variant filenames
       a						:Optional[Any] 							=       [
           '''text_encoder/pytorch_model.bin''',
           '''text_encoder/model.safetensors''',
       ]
       a						:Union[str, Any] 							=       '''fp16'''
       self.assertTrue(is_safetensors_compatible(_lowerCamelCase					,  variant=_lowerCamelCase    )    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       a						:Dict 							=       [
           '''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						:Optional[Any] 							=       '''fp16'''
       self.assertFalse(is_safetensors_compatible(_lowerCamelCase					,  variant=_lowerCamelCase    )    )









def 				__lowerCamelCase						( UpperCAmelCase_						:		int ,  UpperCAmelCase_						:		int						):




      """simple docstring"""





      while b:
            a							,				a						:Optional[Any] 							=       b, a % b
      return a
def 				__lowerCamelCase						( UpperCAmelCase_						:		int ,  UpperCAmelCase_						:		int						):




      """simple docstring"""





      return a if b == 0 else euclidean_gcd_recursive(UpperCAmelCase_ ,  a % b						)
def 				__lowerCamelCase						( ):




      """simple docstring"""





      print(F'''euclidean_gcd(3, 5) = {euclidean_gcd(3 ,  5						)}'''						)
      print(F'''euclidean_gcd(5, 3) = {euclidean_gcd(5 ,  3						)}'''						)
      print(F'''euclidean_gcd(1, 3) = {euclidean_gcd(1 ,  3						)}'''						)
      print(F'''euclidean_gcd(3, 6) = {euclidean_gcd(3 ,  6						)}'''						)
      print(F'''euclidean_gcd(6, 3) = {euclidean_gcd(6 ,  3						)}'''						)

      print(F'''euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3 ,  5						)}'''						)
      print(F'''euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5 ,  3						)}'''						)
      print(F'''euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1 ,  3						)}'''						)
      print(F'''euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3 ,  6						)}'''						)
      print(F'''euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6 ,  3						)}'''						)


if __name__ == "__main__":
     main()





