update

DN6 · DN6 · commit ac4c23c154a4 · 2025-02-20T13:57:18.000+01:00
diff --git a/src/diffusers/pipelines/pipeline_loading_utils.py b/src/diffusers/pipelines/pipeline_loading_utils.py
@@ -165,6 +165,7 @@ def variant_compatible_siblings(filenames, variant=None, ignore_patterns=None) -
         variant_file_re = re.compile(
             rf"({'|'.join(weight_prefixes)})\.({variant}|{variant}-{transformers_index_format})\.({'|'.join(weight_suffixs)})$"
         )
+        legacy_variant_file_re = re.compile(rf".*-{transformers_index_format}\.{variant}\.[a-z]+$")
         # `text_encoder/pytorch_model.bin.index.fp16.json`
         variant_index_re = re.compile(
             rf"({'|'.join(weight_prefixes)})\.({'|'.join(weight_suffixs)})\.index\.{variant}\.json$"
@@ -177,28 +178,16 @@ def variant_compatible_siblings(filenames, variant=None, ignore_patterns=None) -
     # `text_encoder/pytorch_model.bin.index.json`
     non_variant_index_re = re.compile(rf"({'|'.join(weight_prefixes)})\.({'|'.join(weight_suffixs)})\.index\.json")
 
-    def filter_for_compatible_extensions(filenames, variant=None, ignore_patterns=None):
-        def extension_filter(f):
-            return not any(f.endswith(pattern) for pattern in ignore_patterns)
+    def filter_for_compatible_extensions(filenames, ignore_patterns=None):
+        if not ignore_patterns:
+            return filenames
 
-        tensor_files = {f for f in filenames if extension_filter(f)}
-        non_variant_indexes = {
-            f for f in filenames if non_variant_index_re.match(f.split("/")[-1]) is not None and extension_filter(f)
-        }
-        variant_indexes = {
-            f
-            for f in filenames
-            if variant is not None and variant_index_re.match(f.split("/")[-1]) is not None and extension_filter(f)
-        }
-
-        return tensor_files | non_variant_indexes | variant_indexes
+        # ignore patterns uses glob style patterns e.g *.safetensors but we're only
+        # interested in the extension name
+        return {f for f in filenames if not any(f.endswith(pat.lstrip("*.")) for pat in ignore_patterns)}
 
-    def filter_for_weights_and_indexes(filenames, file_re, index_re):
-        weights = {f for f in filenames if file_re.match(f.split("/")[-1]) is not None}
-        indexes = {f for f in filenames if index_re.match(f.split("/")[-1]) is not None}
-        filtered_filenames = weights | indexes
-
-        return filtered_filenames
+    def filter_with_regex(filenames, pattern_re):
+        return {f for f in filenames if pattern_re.match(f.split("/")[-1]) is not None}
 
     # Group files by component
     components = {}
@@ -213,23 +202,27 @@ def filter_for_weights_and_indexes(filenames, file_re, index_re):
     usable_filenames = set()
     variant_filenames = set()
     for component, component_filenames in components.items():
-        component_filenames = filter_for_compatible_extensions(
-            component_filenames, variant=variant, ignore_patterns=ignore_patterns
-        )
+        component_filenames = filter_for_compatible_extensions(component_filenames, ignore_patterns=ignore_patterns)
 
         component_variants = set()
+        component_legacy_variants = set()
+        component_non_variants = set()
         if variant is not None:
-            component_variants = filter_for_weights_and_indexes(component_filenames, variant_file_re, variant_index_re)
+            component_variants = filter_with_regex(component_filenames, variant_file_re)
+            component_legacy_variants = filter_with_regex(component_filenames, legacy_variant_file_re)
+            component_variant_index_files = filter_with_regex(component_filenames, variant_index_re)
 
-        if component_variants:
-            variant_filenames.update(component_variants)
-            usable_filenames.update(component_variants)
+            variant_filenames.update(
+                component_variants if component_variants else component_legacy_variants | component_variant_index_files
+            )
 
         else:
-            component_non_variants = filter_for_weights_and_indexes(
-                component_filenames, non_variant_file_re, non_variant_index_re
-            )
-            usable_filenames.update(component_non_variants)
+            component_non_variants = filter_with_regex(component_filenames, non_variant_file_re)
+            component_variant_index_files = filter_with_regex(component_filenames, non_variant_index_re)
+
+            usable_filenames.update(component_non_variants | component_variant_index_files)
+
+    usable_filenames.update(variant_filenames)
 
     if len(variant_filenames) == 0 and variant is not None:
         error_message = f"You are trying to load the model files of the `variant={variant}`, but no such modeling files are available."
diff --git a/tests/pipelines/test_pipeline_utils.py b/tests/pipelines/test_pipeline_utils.py
@@ -1,6 +1,7 @@
 import contextlib
 import io
 import re
+from shutil import ignore_patterns
 import unittest
 
 import torch
@@ -212,7 +213,7 @@ def test_diffusers_is_compatible_no_components_only_variants(self):
 
 class VariantCompatibleSiblingsTest(unittest.TestCase):
     def test_only_non_variants_downloaded(self):
-        use_safetensors = True
+        ignore_patterns = ["*.bin", "*.msgpack"]
         variant = "fp16"
         filenames = [
             f"vae/diffusion_pytorch_model.{variant}.safetensors",
@@ -224,12 +225,12 @@ def test_only_non_variants_downloaded(self):
         ]
 
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=None, use_safetensors=use_safetensors
+            filenames, variant=None, ignore_patterns=ignore_patterns
         )
         assert all(variant not in f for f in model_filenames)
 
     def test_only_variants_downloaded(self):
-        use_safetensors = True
+        ignore_patterns = ["*.bin", "*.msgpack"]
         variant = "fp16"
         filenames = [
             f"vae/diffusion_pytorch_model.{variant}.safetensors",
@@ -241,12 +242,12 @@ def test_only_variants_downloaded(self):
         ]
 
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant in f for f in model_filenames)
 
     def test_mixed_variants_downloaded(self):
-        use_safetensors = True
+        ignore_patterns = ["*.bin", "*.msgpack"]
         variant = "fp16"
         non_variant_file = "text_encoder/model.safetensors"
         filenames = [
@@ -257,12 +258,12 @@ def test_mixed_variants_downloaded(self):
             "unet/diffusion_pytorch_model.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant in f if f != non_variant_file else variant not in f for f in model_filenames)
 
     def test_non_variants_in_main_dir_downloaded(self):
-        use_safetensors = True
+        ignore_patterns = ["*.bin", "*.msgpack"]
         variant = "fp16"
         filenames = [
             f"diffusion_pytorch_model.{variant}.safetensors",
@@ -271,12 +272,11 @@ def test_non_variants_in_main_dir_downloaded(self):
             f"model.{variant}.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=None, use_safetensors=use_safetensors
+            filenames, variant=None, ignore_patterns=ignore_patterns
         )
         assert all(variant not in f for f in model_filenames)
 
     def test_variants_in_main_dir_downloaded(self):
-        use_safetensors = True
         variant = "fp16"
         filenames = [
             f"diffusion_pytorch_model.{variant}.safetensors",
@@ -287,7 +287,7 @@ def test_variants_in_main_dir_downloaded(self):
             "diffusion_pytorch_model.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant in f for f in model_filenames)
 
@@ -301,7 +301,7 @@ def test_mixed_variants_in_main_dir_downloaded(self):
             "model.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant in f if f != non_variant_file else variant not in f for f in model_filenames)
 
@@ -318,7 +318,7 @@ def test_sharded_variants_in_main_dir_downloaded(self):
             f"diffusion_pytorch_model.safetensors.index.{variant}.json",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant in f for f in model_filenames)
 
@@ -333,7 +333,7 @@ def test_mixed_sharded_and_variant_in_main_dir_downloaded(self):
             f"diffusion_pytorch_model.{variant}.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant in f for f in model_filenames)
 
@@ -350,7 +350,7 @@ def test_mixed_sharded_non_variants_in_main_dir_downloaded(self):
             f"diffusion_pytorch_model.{variant}-00002-of-00002.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=None, use_safetensors=use_safetensors
+            filenames, variant=None, ignore_patterns=ignore_patterns
         )
         assert all(variant not in f for f in model_filenames)
 
@@ -367,7 +367,7 @@ def test_sharded_non_variants_downloaded(self):
             f"unet/diffusion_pytorch_model.{variant}-00002-of-00002.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=None, use_safetensors=use_safetensors
+            filenames, variant=None, ignore_patterns=ignore_patterns
         )
         assert all(variant not in f for f in model_filenames)
 
@@ -384,7 +384,7 @@ def test_sharded_variants_downloaded(self):
             f"unet/diffusion_pytorch_model.{variant}-00002-of-00002.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant in f for f in model_filenames)
 
@@ -399,7 +399,7 @@ def test_single_variant_with_sharded_non_variant_downloaded(self):
             f"unet/diffusion_pytorch_model.{variant}.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant in f for f in model_filenames)
 
@@ -419,7 +419,7 @@ def test_mixed_single_variant_with_sharded_non_variant_downloaded(self):
             "unet/diffusion_pytorch_model-00003-of-00003.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant in f if allowed_non_variant not in f else variant not in f for f in model_filenames)
 
@@ -441,7 +441,7 @@ def test_sharded_mixed_variants_downloaded(self):
             "vae/diffusion_pytorch_model-00003-of-00003.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant in f if allowed_non_variant not in f else variant not in f for f in model_filenames)
 
@@ -457,7 +457,7 @@ def test_variant_ignored_if_use_safetensors(self):
             "unet/diffusion_pytorch_model.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant not in f for f in model_filenames)
 
@@ -466,7 +466,7 @@ def test_downloading_when_no_variant_exists(self):
         variant = "fp16"
         filenames = ["model.safetensors", "diffusion_pytorch_model.safetensors"]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert len(model_filenames) != 0
 
@@ -475,7 +475,7 @@ def test_downloading_use_safetensors_no_variant_exists(self):
         variant = "fp16"
         filenames = ["text_encoder/model.bin", "unet/diffusion_pytorch_model.bin"]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant not in f for f in model_filenames)
 
@@ -488,7 +488,7 @@ def test_downloading_use_safetensors_false(self):
             "unet/diffusion_pytorch_model.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
 
         assert all(".safetensors" not in f for f in model_filenames)
@@ -502,7 +502,7 @@ def test_non_variant_in_main_dir_with_variant_in_subfolder(self):
             "diffusion_pytorch_model.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant in f if allowed_non_variant not in f else variant not in f for f in model_filenames)
 
@@ -515,7 +515,7 @@ def test_download_variants_when_component_has_no_variant(self):
             f"vae/diffusion_pytorch_model.{variant}.safetensors",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert {
             f"unet/diffusion_pytorch_model.{variant}.bin",
@@ -539,7 +539,7 @@ def test_download_sharded_variants_when_component_has_no_safetensors_variant(sel
             f"vae/diffusion_pytorch_model.{variant}-00001-of-00002.bin",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant not in f for f in model_filenames)
 
@@ -561,7 +561,7 @@ def test_download_sharded_variants_when_component_has_no_safetensors_variant_and
             f"vae/diffusion_pytorch_model.{variant}-00001-of-00002.bin",
         ]
         model_filenames, variant_filenames = variant_compatible_siblings(
-            filenames, variant=variant, use_safetensors=use_safetensors
+            filenames, variant=variant, ignore_patterns=ignore_patterns
         )
         assert all(variant in f if allowed_non_variant not in f else variant not in f for f in model_filenames)
 

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`import contextlib`
`2`	`2`	`import io`
`3`	`3`	`import re`
	`4`	`+from shutil import ignore_patterns`
`4`	`5`	`import unittest`
`5`	`6`
`6`	`7`	`import torch`
`@@ -212,7 +213,7 @@ def test_diffusers_is_compatible_no_components_only_variants(self):`
`212`	`213`
`213`	`214`	`class VariantCompatibleSiblingsTest(unittest.TestCase):`
`214`	`215`	`def test_only_non_variants_downloaded(self):`
`215`		`- use_safetensors = True`
	`216`	`+ ignore_patterns = [".bin", ".msgpack"]`
`216`	`217`	`variant = "fp16"`
`217`	`218`	`filenames = [`
`218`	`219`	`f"vae/diffusion_pytorch_model.{variant}.safetensors",`
`@@ -224,12 +225,12 @@ def test_only_non_variants_downloaded(self):`
`224`	`225`	`]`
`225`	`226`
`226`	`227`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`227`		`- filenames, variant=None, use_safetensors=use_safetensors`
	`228`	`+ filenames, variant=None, ignore_patterns=ignore_patterns`
`228`	`229`	`)`
`229`	`230`	`assert all(variant not in f for f in model_filenames)`
`230`	`231`
`231`	`232`	`def test_only_variants_downloaded(self):`
`232`		`- use_safetensors = True`
	`233`	`+ ignore_patterns = [".bin", ".msgpack"]`
`233`	`234`	`variant = "fp16"`
`234`	`235`	`filenames = [`
`235`	`236`	`f"vae/diffusion_pytorch_model.{variant}.safetensors",`
`@@ -241,12 +242,12 @@ def test_only_variants_downloaded(self):`
`241`	`242`	`]`
`242`	`243`
`243`	`244`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`244`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`245`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`245`	`246`	`)`
`246`	`247`	`assert all(variant in f for f in model_filenames)`
`247`	`248`
`248`	`249`	`def test_mixed_variants_downloaded(self):`
`249`		`- use_safetensors = True`
	`250`	`+ ignore_patterns = [".bin", ".msgpack"]`
`250`	`251`	`variant = "fp16"`
`251`	`252`	`non_variant_file = "text_encoder/model.safetensors"`
`252`	`253`	`filenames = [`
`@@ -257,12 +258,12 @@ def test_mixed_variants_downloaded(self):`
`257`	`258`	`"unet/diffusion_pytorch_model.safetensors",`
`258`	`259`	`]`
`259`	`260`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`260`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`261`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`261`	`262`	`)`
`262`	`263`	`assert all(variant in f if f != non_variant_file else variant not in f for f in model_filenames)`
`263`	`264`
`264`	`265`	`def test_non_variants_in_main_dir_downloaded(self):`
`265`		`- use_safetensors = True`
	`266`	`+ ignore_patterns = [".bin", ".msgpack"]`
`266`	`267`	`variant = "fp16"`
`267`	`268`	`filenames = [`
`268`	`269`	`f"diffusion_pytorch_model.{variant}.safetensors",`
`@@ -271,12 +272,11 @@ def test_non_variants_in_main_dir_downloaded(self):`
`271`	`272`	`f"model.{variant}.safetensors",`
`272`	`273`	`]`
`273`	`274`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`274`		`- filenames, variant=None, use_safetensors=use_safetensors`
	`275`	`+ filenames, variant=None, ignore_patterns=ignore_patterns`
`275`	`276`	`)`
`276`	`277`	`assert all(variant not in f for f in model_filenames)`
`277`	`278`
`278`	`279`	`def test_variants_in_main_dir_downloaded(self):`
`279`		`- use_safetensors = True`
`280`	`280`	`variant = "fp16"`
`281`	`281`	`filenames = [`
`282`	`282`	`f"diffusion_pytorch_model.{variant}.safetensors",`
`@@ -287,7 +287,7 @@ def test_variants_in_main_dir_downloaded(self):`
`287`	`287`	`"diffusion_pytorch_model.safetensors",`
`288`	`288`	`]`
`289`	`289`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`290`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`290`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`291`	`291`	`)`
`292`	`292`	`assert all(variant in f for f in model_filenames)`
`293`	`293`
`@@ -301,7 +301,7 @@ def test_mixed_variants_in_main_dir_downloaded(self):`
`301`	`301`	`"model.safetensors",`
`302`	`302`	`]`
`303`	`303`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`304`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`304`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`305`	`305`	`)`
`306`	`306`	`assert all(variant in f if f != non_variant_file else variant not in f for f in model_filenames)`
`307`	`307`
`@@ -318,7 +318,7 @@ def test_sharded_variants_in_main_dir_downloaded(self):`
`318`	`318`	`f"diffusion_pytorch_model.safetensors.index.{variant}.json",`
`319`	`319`	`]`
`320`	`320`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`321`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`321`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`322`	`322`	`)`
`323`	`323`	`assert all(variant in f for f in model_filenames)`
`324`	`324`
`@@ -333,7 +333,7 @@ def test_mixed_sharded_and_variant_in_main_dir_downloaded(self):`
`333`	`333`	`f"diffusion_pytorch_model.{variant}.safetensors",`
`334`	`334`	`]`
`335`	`335`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`336`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`336`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`337`	`337`	`)`
`338`	`338`	`assert all(variant in f for f in model_filenames)`
`339`	`339`
`@@ -350,7 +350,7 @@ def test_mixed_sharded_non_variants_in_main_dir_downloaded(self):`
`350`	`350`	`f"diffusion_pytorch_model.{variant}-00002-of-00002.safetensors",`
`351`	`351`	`]`
`352`	`352`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`353`		`- filenames, variant=None, use_safetensors=use_safetensors`
	`353`	`+ filenames, variant=None, ignore_patterns=ignore_patterns`
`354`	`354`	`)`
`355`	`355`	`assert all(variant not in f for f in model_filenames)`
`356`	`356`
`@@ -367,7 +367,7 @@ def test_sharded_non_variants_downloaded(self):`
`367`	`367`	`f"unet/diffusion_pytorch_model.{variant}-00002-of-00002.safetensors",`
`368`	`368`	`]`
`369`	`369`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`370`		`- filenames, variant=None, use_safetensors=use_safetensors`
	`370`	`+ filenames, variant=None, ignore_patterns=ignore_patterns`
`371`	`371`	`)`
`372`	`372`	`assert all(variant not in f for f in model_filenames)`
`373`	`373`
`@@ -384,7 +384,7 @@ def test_sharded_variants_downloaded(self):`
`384`	`384`	`f"unet/diffusion_pytorch_model.{variant}-00002-of-00002.safetensors",`
`385`	`385`	`]`
`386`	`386`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`387`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`387`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`388`	`388`	`)`
`389`	`389`	`assert all(variant in f for f in model_filenames)`
`390`	`390`
`@@ -399,7 +399,7 @@ def test_single_variant_with_sharded_non_variant_downloaded(self):`
`399`	`399`	`f"unet/diffusion_pytorch_model.{variant}.safetensors",`
`400`	`400`	`]`
`401`	`401`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`402`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`402`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`403`	`403`	`)`
`404`	`404`	`assert all(variant in f for f in model_filenames)`
`405`	`405`
`@@ -419,7 +419,7 @@ def test_mixed_single_variant_with_sharded_non_variant_downloaded(self):`
`419`	`419`	`"unet/diffusion_pytorch_model-00003-of-00003.safetensors",`
`420`	`420`	`]`
`421`	`421`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`422`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`422`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`423`	`423`	`)`
`424`	`424`	`assert all(variant in f if allowed_non_variant not in f else variant not in f for f in model_filenames)`
`425`	`425`
`@@ -441,7 +441,7 @@ def test_sharded_mixed_variants_downloaded(self):`
`441`	`441`	`"vae/diffusion_pytorch_model-00003-of-00003.safetensors",`
`442`	`442`	`]`
`443`	`443`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`444`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`444`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`445`	`445`	`)`
`446`	`446`	`assert all(variant in f if allowed_non_variant not in f else variant not in f for f in model_filenames)`
`447`	`447`
`@@ -457,7 +457,7 @@ def test_variant_ignored_if_use_safetensors(self):`
`457`	`457`	`"unet/diffusion_pytorch_model.safetensors",`
`458`	`458`	`]`
`459`	`459`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`460`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`460`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`461`	`461`	`)`
`462`	`462`	`assert all(variant not in f for f in model_filenames)`
`463`	`463`
`@@ -466,7 +466,7 @@ def test_downloading_when_no_variant_exists(self):`
`466`	`466`	`variant = "fp16"`
`467`	`467`	`filenames = ["model.safetensors", "diffusion_pytorch_model.safetensors"]`
`468`	`468`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`469`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`469`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`470`	`470`	`)`
`471`	`471`	`assert len(model_filenames) != 0`
`472`	`472`
`@@ -475,7 +475,7 @@ def test_downloading_use_safetensors_no_variant_exists(self):`
`475`	`475`	`variant = "fp16"`
`476`	`476`	`filenames = ["text_encoder/model.bin", "unet/diffusion_pytorch_model.bin"]`
`477`	`477`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`478`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`478`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`479`	`479`	`)`
`480`	`480`	`assert all(variant not in f for f in model_filenames)`
`481`	`481`
`@@ -488,7 +488,7 @@ def test_downloading_use_safetensors_false(self):`
`488`	`488`	`"unet/diffusion_pytorch_model.safetensors",`
`489`	`489`	`]`
`490`	`490`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`491`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`491`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`492`	`492`	`)`
`493`	`493`
`494`	`494`	`assert all(".safetensors" not in f for f in model_filenames)`
`@@ -502,7 +502,7 @@ def test_non_variant_in_main_dir_with_variant_in_subfolder(self):`
`502`	`502`	`"diffusion_pytorch_model.safetensors",`
`503`	`503`	`]`
`504`	`504`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`505`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`505`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`506`	`506`	`)`
`507`	`507`	`assert all(variant in f if allowed_non_variant not in f else variant not in f for f in model_filenames)`
`508`	`508`
`@@ -515,7 +515,7 @@ def test_download_variants_when_component_has_no_variant(self):`
`515`	`515`	`f"vae/diffusion_pytorch_model.{variant}.safetensors",`
`516`	`516`	`]`
`517`	`517`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`518`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`518`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`519`	`519`	`)`
`520`	`520`	`assert {`
`521`	`521`	`f"unet/diffusion_pytorch_model.{variant}.bin",`
`@@ -539,7 +539,7 @@ def test_download_sharded_variants_when_component_has_no_safetensors_variant(sel`
`539`	`539`	`f"vae/diffusion_pytorch_model.{variant}-00001-of-00002.bin",`
`540`	`540`	`]`
`541`	`541`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`542`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`542`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`543`	`543`	`)`
`544`	`544`	`assert all(variant not in f for f in model_filenames)`
`545`	`545`
`@@ -561,7 +561,7 @@ def test_download_sharded_variants_when_component_has_no_safetensors_variant_and`
`561`	`561`	`f"vae/diffusion_pytorch_model.{variant}-00001-of-00002.bin",`
`562`	`562`	`]`
`563`	`563`	`model_filenames, variant_filenames = variant_compatible_siblings(`
`564`		`- filenames, variant=variant, use_safetensors=use_safetensors`
	`564`	`+ filenames, variant=variant, ignore_patterns=ignore_patterns`
`565`	`565`	`)`
`566`	`566`	`assert all(variant in f if allowed_non_variant not in f else variant not in f for f in model_filenames)`
`567`	`567`