cache-dit 1.0.8__py3-none-any.whl → 1.0.9__py3-none-any.whl

cache_dit/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.0.8'
-__version_tuple__ = version_tuple = (1, 0, 8)
+__version__ = version = '1.0.9'
+__version_tuple__ = version_tuple = (1, 0, 9)
 
 __commit_id__ = commit_id = None

cache_dit/cache_factory/block_adapters/block_adapters.py

@@ -489,6 +489,7 @@ class BlockAdapter:
     @staticmethod
     def normalize(
         adapter: "BlockAdapter",
+        unique: bool = True,
     ) -> "BlockAdapter":
 
         if getattr(adapter, "_is_normalized", False):
@@ -523,7 +524,10 @@ class BlockAdapter:
         adapter.forward_pattern = _normalize_attr(adapter.forward_pattern)
         adapter.dummy_blocks_names = _normalize_attr(adapter.dummy_blocks_names)
         adapter.params_modifiers = _normalize_attr(adapter.params_modifiers)
-        BlockAdapter.unique(adapter)
+        # Some times, the cache_config will be None.
+        # So we do not perform unique check here.
+        if unique:
+            BlockAdapter.unique(adapter)
 
         adapter._is_normalized = True
 
@@ -571,6 +575,10 @@ class BlockAdapter:
         if not getattr(adapter, "_is_normalized", False):
             raise RuntimeError("block_adapter must be normailzed.")
 
+    @classmethod
+    def is_normalized(cls, adapter: "BlockAdapter") -> bool:
+        return getattr(adapter, "_is_normalized", False)
+
     @classmethod
     def is_cached(cls, adapter: Any) -> bool:
         if isinstance(adapter, cls):
@@ -592,6 +600,21 @@ class BlockAdapter:
         else:
             return getattr(adapter, "_is_cached", False)
 
+    @classmethod
+    def is_parallelized(cls, adapter: Any) -> bool:
+        if isinstance(adapter, cls):
+            cls.assert_normalized(adapter)
+            return getattr(adapter.transformer[0], "_is_parallelized", False)
+        elif isinstance(adapter, DiffusionPipeline):
+            return getattr(adapter.transformer, "_is_parallelized", False)
+        elif isinstance(adapter, torch.nn.Module):
+            return getattr(adapter, "_is_parallelized", False)
+        elif isinstance(adapter, list):  # [TRN_0,...]
+            assert isinstance(adapter[0], torch.nn.Module)
+            return getattr(adapter[0], "_is_parallelized", False)
+        else:
+            return getattr(adapter, "_is_parallelized", False)
+
     @classmethod
     def nested_depth(cls, obj: Any):
         # str: 0; List[str]: 1; List[List[str]]: 2

cache_dit/cache_factory/block_adapters/block_registers.py

@@ -37,7 +37,7 @@ class BlockAdapterRegistry:
         cls,
         pipe: DiffusionPipeline | str | Any,
         **kwargs,
-    ) -> BlockAdapter:
+    ) -> BlockAdapter | None:
         if not isinstance(pipe, str):
             pipe_cls_name: str = pipe.__class__.__name__
         else:
@@ -47,7 +47,7 @@ class BlockAdapterRegistry:
             if pipe_cls_name.startswith(name):
                 return cls._adapters[name](pipe, **kwargs)
 
-        return BlockAdapter()
+        return None
 
     @classmethod
     def has_separate_cfg(

cache_dit/cache_factory/cache_adapters/cache_adapter.py

@@ -52,6 +52,10 @@ class CachedAdapter:
                 block_adapter = BlockAdapterRegistry.get_adapter(
                     pipe_or_adapter
                 )
+                assert block_adapter is not None, (
+                    f"BlockAdapter for {pipe_or_adapter.__class__.__name__} "
+                    "should not be None!"
+                )
                 if params_modifiers := context_kwargs.pop(
                     "params_modifiers",
                     None,

cache_dit/cache_factory/cache_interface.py

@@ -24,11 +24,13 @@ def enable_cache(
         BlockAdapter,
     ],
     # BasicCacheConfig, DBCacheConfig, DBPruneConfig, etc.
-    cache_config: Union[
-        BasicCacheConfig,
-        DBCacheConfig,
-        DBPruneConfig,
-    ] = DBCacheConfig(),
+    cache_config: Optional[
+        Union[
+            BasicCacheConfig,
+            DBCacheConfig,
+            DBPruneConfig,
+        ]
+    ] = None,
     # Calibrator config: TaylorSeerCalibratorConfig, etc.
     calibrator_config: Optional[CalibratorConfig] = None,
     # Modify cache context params for specific blocks.
@@ -154,13 +156,27 @@ def enable_cache(
     >>> stats = cache_dit.summary(pipe) # Then, get the summary of cache acceleration stats.
     >>> cache_dit.disable_cache(pipe) # Disable cache and run original pipe.
     """
+    # Precheck for compatibility of different configurations
+    if cache_config is None:
+        if parallelism_config is None:
+            # Set default cache config only when parallelism is not enabled
+            logger.info("cache_config is None, using default DBCacheConfig")
+            cache_config = DBCacheConfig()
+        else:
+            # Allow empty cache_config when parallelism is enabled
+            logger.warning(
+                "Parallelism is enabled and cache_config is None. Please manually "
+                "set cache_config to avoid potential compatibility issues. "
+                "Otherwise, cache will not be enabled."
+            )
+
     # Collect cache context kwargs
     context_kwargs = {}
     if (cache_type := context_kwargs.get("cache_type", None)) is not None:
         if cache_type == CacheType.NONE:
             return pipe_or_adapter
 
-    # WARNING: Deprecated cache config params. These parameters are now retained
+    # NOTE: Deprecated cache config params. These parameters are now retained
     # for backward compatibility but will be removed in the future.
     deprecated_kwargs = {
         "Fn_compute_blocks": kwargs.get("Fn_compute_blocks", None),
@@ -196,9 +212,9 @@ def enable_cache(
     if cache_config is not None:
         context_kwargs["cache_config"] = cache_config
 
-    # WARNING: Deprecated taylorseer params. These parameters are now retained
+    # NOTE: Deprecated taylorseer params. These parameters are now retained
     # for backward compatibility but will be removed in the future.
-    if (
+    if cache_config is not None and (
         kwargs.get("enable_taylorseer", None) is not None
         or kwargs.get("enable_encoder_taylorseer", None) is not None
     ):
@@ -226,16 +242,22 @@ def enable_cache(
     if params_modifiers is not None:
         context_kwargs["params_modifiers"] = params_modifiers
 
-    if isinstance(pipe_or_adapter, (DiffusionPipeline, BlockAdapter)):
-        pipe_or_adapter = CachedAdapter.apply(
-            pipe_or_adapter,
-            **context_kwargs,
-        )
+    if cache_config is not None:
+        if isinstance(pipe_or_adapter, (DiffusionPipeline, BlockAdapter)):
+            pipe_or_adapter = CachedAdapter.apply(
+                pipe_or_adapter,
+                **context_kwargs,
+            )
+        else:
+            raise ValueError(
+                f"type: {type(pipe_or_adapter)} is not valid, "
+                "Please pass DiffusionPipeline or BlockAdapter"
+                "for the 1's position param: pipe_or_adapter"
+            )
     else:
-        raise ValueError(
-            f"type: {type(pipe_or_adapter)} is not valid, "
-            "Please pass DiffusionPipeline or BlockAdapter"
-            "for the 1's position param: pipe_or_adapter"
+        logger.warning(
+            "cache_config is None, skip enabling cache for "
+            f"{pipe_or_adapter.__class__.__name__}."
         )
 
     # NOTE: Users should always enable parallelism after applying
@@ -244,19 +266,45 @@ def enable_cache(
         assert isinstance(
             parallelism_config, ParallelismConfig
         ), "parallelism_config should be of type ParallelismConfig."
+
+        transformers = []
         if isinstance(pipe_or_adapter, DiffusionPipeline):
-            transformer = pipe_or_adapter.transformer
+            adapter = BlockAdapterRegistry.get_adapter(pipe_or_adapter)
+            if adapter is None:
+                assert hasattr(pipe_or_adapter, "transformer"), (
+                    "The given DiffusionPipeline does not have "
+                    "a 'transformer' attribute, cannot enable "
+                    "parallelism."
+                )
+                transformers = [pipe_or_adapter.transformer]
+            else:
+                adapter = BlockAdapter.normalize(adapter, unique=False)
+                transformers = BlockAdapter.flatten(adapter.transformer)
         else:
-            assert BlockAdapter.assert_normalized(pipe_or_adapter)
-            assert (
-                len(BlockAdapter.flatten(pipe_or_adapter.transformer)) == 1
-            ), (
-                "Only single transformer is supported to enable parallelism "
-                "currently for BlockAdapter."
+            if not BlockAdapter.is_normalized(pipe_or_adapter):
+                pipe_or_adapter = BlockAdapter.normalize(
+                    pipe_or_adapter, unique=False
+                )
+            transformers = BlockAdapter.flatten(pipe_or_adapter.transformer)
+
+        if len(transformers) == 0:
+            logger.warning(
+                "No transformer is detected in the "
+                "BlockAdapter, skip enabling parallelism."
+            )
+            return pipe_or_adapter
+
+        if len(transformers) > 1:
+            logger.warning(
+                "Multiple transformers are detected in the "
+                "BlockAdapter, all transfomers will be "
+                "enabled for parallelism."
+            )
+        for i, transformer in enumerate(transformers):
+            # Enable parallelism for the transformer inplace
+            transformers[i] = enable_parallelism(
+                transformer, parallelism_config
             )
-            transformer = BlockAdapter.flatten(pipe_or_adapter.transformer)[0]
-        # Enable parallelism for the transformer inplace
-        transformer = enable_parallelism(transformer, parallelism_config)
     return pipe_or_adapter
 
 

cache_dit/parallelism/backends/native_diffusers/parallel_difffusers.py

@@ -54,15 +54,27 @@ def maybe_enable_parallelism(
                 ring_degree=parallelism_config.ring_size,
             )
         if cp_config is not None:
+            attention_backend = parallelism_config.parallel_kwargs.get(
+                "attention_backend", None
+            )
             if hasattr(transformer, "enable_parallelism"):
                 if hasattr(transformer, "set_attention_backend"):
-                    # Now only _native_cudnn is supported for parallelism
-                    # issue: https://github.com/huggingface/diffusers/pull/12443
-                    transformer.set_attention_backend("_native_cudnn")
-                    logger.warning(
-                        "Set attention backend to _native_cudnn for parallelism because of "
-                        "the issue: https://github.com/huggingface/diffusers/pull/12443"
-                    )
+                    # _native_cudnn, flash, etc.
+                    if attention_backend is None:
+                        # Now only _native_cudnn is supported for parallelism
+                        # issue: https://github.com/huggingface/diffusers/pull/12443
+                        transformer.set_attention_backend("_native_cudnn")
+                        logger.warning(
+                            "attention_backend is None, set default attention backend "
+                            "to _native_cudnn for parallelism because of the issue: "
+                            "https://github.com/huggingface/diffusers/pull/12443"
+                        )
+                    else:
+                        transformer.set_attention_backend(attention_backend)
+                        logger.info(
+                            "Found attention_backend from config, set attention "
+                            f"backend to: {attention_backend}"
+                        )
                 cp_plan = parallelism_config.parallel_kwargs.get(
                     "cp_plan", None
                 )

cache_dit/parallelism/parallel_config.py

@@ -23,8 +23,8 @@ class ParallelismConfig:
     tp_size: int = None
     # parallel_kwargs (`dict`, *optional*):
     #     Additional kwargs for parallelism backends. For example, for
-    #     NATIVE_DIFFUSER backend, it can include `cp_plan` and other
-    #     arguments for `Context Parallelism`.
+    #     NATIVE_DIFFUSER backend, it can include `cp_plan` and
+    #     `attention_backend` arguments for `Context Parallelism`.
     parallel_kwargs: Optional[Dict[str, Any]] = dataclasses.field(
         default_factory=dict
     )

cache_dit/parallelism/parallel_interface.py

@@ -40,8 +40,12 @@ def enable_parallelism(
         )
 
     transformer._is_parallelized = True  # type: ignore[attr-defined]
+    # Use `parallelism` not `parallel` to avoid name conflict with diffusers.
     transformer._parallelism_config = parallelism_config  # type: ignore[attr-defined]
-    logger.info(f"Enabled parallelism: {parallelism_config.strify(True)}")
+    logger.info(
+        f"Enabled parallelism: {parallelism_config.strify(True)}, "
+        f"transformer id:{id(transformer)}"
+    )
     return transformer
 
 

cache_dit/utils.py

@@ -79,25 +79,31 @@ def summary(
             transformer_2 = None
         else:
             transformer = adapter_or_others.transformer
-            transformer_2 = None
+            transformer_2 = None  # Only for Wan2.2
             if hasattr(adapter_or_others, "transformer_2"):
                 transformer_2 = adapter_or_others.transformer_2
 
-        if not BlockAdapter.is_cached(transformer):
+        if all(
+            (
+                not BlockAdapter.is_cached(transformer),
+                not BlockAdapter.is_parallelized(transformer),
+            )
+        ):
             return [CacheStats()]
 
         blocks_stats: List[CacheStats] = []
-        for blocks in BlockAdapter.find_blocks(transformer):
-            blocks_stats.append(
-                _summary(
-                    blocks,
-                    details=details,
-                    logging=logging,
-                    **kwargs,
+        if BlockAdapter.is_cached(transformer):
+            for blocks in BlockAdapter.find_blocks(transformer):
+                blocks_stats.append(
+                    _summary(
+                        blocks,
+                        details=details,
+                        logging=logging,
+                        **kwargs,
+                    )
                 )
-            )
 
-        if transformer_2 is not None:
+        if transformer_2 is not None and BlockAdapter.is_cached(transformer_2):
             for blocks in BlockAdapter.find_blocks(transformer_2):
                 blocks_stats.append(
                     _summary(
@@ -126,7 +132,11 @@ def summary(
                 )
             )
 
-        blocks_stats = [stats for stats in blocks_stats if stats.cache_options]
+        blocks_stats = [
+            stats
+            for stats in blocks_stats
+            if (stats.cache_options or stats.parallelism_config)
+        ]
 
         return blocks_stats if len(blocks_stats) else [CacheStats()]
 
@@ -160,6 +170,8 @@ def strify(
         Dict[str, Any],
     ],
 ) -> str:
+
+    parallelism_config: ParallelismConfig = None
     if isinstance(adapter_or_others, BlockAdapter):
         stats = summary(adapter_or_others, logging=False)[-1]
         cache_options = stats.cache_options
@@ -182,8 +194,8 @@ def strify(
         cache_options = adapter_or_others
         cached_steps = None
         cache_type = cache_options.get("cache_type", CacheType.NONE)
-
         stats = None
+        parallelism_config = cache_options.get("parallelism_config", None)
 
         if cache_type == CacheType.NONE:
             return "NONE"
@@ -193,7 +205,10 @@ def strify(
             "DiffusionPipeline | CacheStats | Dict[str, Any]"
         )
 
-    if not cache_options:
+    if stats is not None:
+        parallelism_config = stats.parallelism_config
+
+    if not cache_options and parallelism_config is None:
         return "NONE"
 
     def cache_str():
@@ -219,14 +234,14 @@ def strify(
         return "T0O0"
 
     def parallelism_str():
-        if stats is None:
-            return ""
-        parallelism_config: ParallelismConfig = stats.parallelism_config
         if parallelism_config is not None:
             return f"_{parallelism_config.strify()}"
         return ""
 
-    cache_type_str = f"{cache_str()}_{calibrator_str()}{parallelism_str()}"
+    cache_type_str = f"{cache_str()}"
+    if cache_type_str != "NONE":
+        cache_type_str += f"_{calibrator_str()}"
+    cache_type_str += f"{parallelism_str()}"
 
     if cached_steps:
         cache_type_str += f"_S{cached_steps}"
@@ -245,6 +260,7 @@ def _summary(
 ) -> CacheStats:
     cache_stats = CacheStats()
 
+    # Get stats from transformer
     if not isinstance(pipe_or_module, torch.nn.Module):
         assert hasattr(pipe_or_module, "transformer")
         module = pipe_or_module.transformer

{cache_dit-1.0.8.dist-info → cache_dit-1.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cache_dit
-Version: 1.0.8
+Version: 1.0.9
 Summary: A Unified, Flexible and Training-free Cache Acceleration Framework for 🤗Diffusers.
 Author: DefTruth, vipshop.com, etc.
 Maintainer: DefTruth, vipshop.com, etc
@@ -48,8 +48,9 @@ Dynamic: requires-python
   <p align="center">
     A <b>Unified</b>, Flexible and Training-free <b>Cache Acceleration</b> Framework for <b>🤗Diffusers</b> <br>
     ♥️ Cache Acceleration with <b>One-line</b> Code ~ ♥️ <br>
-    🔥<b><a href="./docs/User_Guide.md">DBCache</a> | <a href="./docs/User_Guide.md">DBPrune</a> | <a href="./docs/User_Guide.md">Hybrid TaylorSeer</a> | <a href="./docs/User_Guide.md">Hybrid Cache CFG</a></b>🔥 <br> 
-    🔥<b><a href="./docs/User_Guide.md">Hybrid Context Paralleism</a> | <a href="./docs/User_Guide.md">Diffusers Native</a> | <a href="./docs/User_Guide.md">SOTA</a></b>🔥
+    🔥<a href="./docs/User_Guide.md">Forward Pattern Matching</a> | <a href="./docs/User_Guide.md">Automatic Block Adapter</a>🔥 <br>
+    🔥<a href="./docs/User_Guide.md"><b>DBCache</b></a> | <a href="./docs/User_Guide.md"><b>DBPrune</b></a> | <a href="./docs/User_Guide.md">Hybrid <b>TaylorSeer</b> Calibrator</a> | <a href="./docs/User_Guide.md">Cache CFG</a>🔥<br>
+    🔥<a href="./docs/User_Guide.md"><b>Context Parallelism</b></a> | <a href="./docs/User_Guide.md">Torch Compile Compatible</a> | <a href="./docs/User_Guide.md">SOTA</a>🔥 
   </p>
   <div align='center'>
       <img src=https://img.shields.io/badge/Language-Python-brightgreen.svg >
@@ -169,7 +170,7 @@ Dynamic: requires-python
 ## 🔥Hightlight <a href="https://huggingface.co/docs/diffusers/main/en/optimization/cache_dit"><img src=https://img.shields.io/badge/🤗Diffusers-ecosystem-yellow.svg ></a>
 
 We are excited to announce that the **first API-stable version (v1.0.0)** of cache-dit has finally been released!
-**[cache-dit](https://github.com/vipshop/cache-dit)** is a **Unified**, **Flexible**, and **Training-free** cache acceleration framework for 🤗 Diffusers, enabling cache acceleration with just **one line** of code. Key features: **Unified Cache APIs**, **Forward Pattern Matching**, **Automatic Block Adapter**, **Hybrid Forward Pattern**, **DBCache**, **DBPrune**, **TaylorSeer Calibrator**, and **Cache CFG**.   
+**[cache-dit](https://github.com/vipshop/cache-dit)** is a **Unified**, **Flexible**, and **Training-free** cache acceleration framework for 🤗 Diffusers, enabling cache acceleration with just **one line** of code. Key features: **Unified Cache APIs**, **Forward Pattern Matching**, **Automatic Block Adapter**, **DBCache**, **DBPrune**, **Hybrid TaylorSeer Calibrator**, **Hybrid Cache CFG**, **Context Parallelism**, **Torch Compile Compatible** and **🎉SOTA** performance.
 
 ```bash
 pip3 install -U cache-dit # pip3 install git+https://github.com/vipshop/cache-dit.git
@@ -200,6 +201,7 @@ You can install the stable release of cache-dit from PyPI, or the latest develop
 
 ## 🔥Important News
 
+- 2025.10.23: 🎉Now cache-dit supported the [Kandinsky5 T2V](https://github.com/ai-forever/Kandinsky-5) and [Photoroom/PRX](https://github.com/huggingface/diffusers/pull/12456) pipelines.
 - 2025.10.20: 🔥Now cache-dit supported the **[Hybrid Cache + Context Parallelism](./docs/User_Guide.md/#️hybrid-context-parallelism)** scheme!🔥
 - 2025.10.16: 🎉cache-dit + [**🔥nunchaku 4-bits**](https://github.com/nunchaku-tech/nunchaku) supported: [Qwen-Image-Lightning 4/8 steps](./examples/quantize/).
 - 2025.10.15: 🎉cache-dit now supported [**🔥nunchaku**](https://github.com/nunchaku-tech/nunchaku): Qwen-Image/FLUX.1 [4-bits examples](./examples/quantize/)

{cache_dit-1.0.8.dist-info → cache_dit-1.0.9.dist-info}/RECORD

@@ -1,19 +1,19 @@
 cache_dit/__init__.py,sha256=Azqj-3QMQK4HZDTGgyUtAfatUwuU-YQ4w8erJSyrsbE,2082
-cache_dit/_version.py,sha256=09KGe_qkXH8vhvX180khtkldtbrAX-u8refqVsC-Ky4,704
+cache_dit/_version.py,sha256=JXTThZsIEQNG8lSfLsQqv8iVrLso3IkPevWFvCathJU,704
 cache_dit/logger.py,sha256=0zsu42hN-3-rgGC_C29ms1IvVpV4_b4_SwJCKSenxBE,4304
-cache_dit/utils.py,sha256=3NcEb324fNY0NYnrBTjsLURKQuckKeFe3V9Dfc_g4sc,17851
+cache_dit/utils.py,sha256=rjVXUyr7JUabO9bY2puXrfPvHl3Sp4eX3MHLY90Cau8,18432
 cache_dit/cache_factory/.gitignore,sha256=5Cb-qT9wsTUoMJ7vACDF7ZcLpAXhi5v-xdcWSRit988,23
 cache_dit/cache_factory/__init__.py,sha256=5UjrpxLVlmjHttTL0O14fD5oU5uKI3FKYevL613ibFQ,1848
-cache_dit/cache_factory/cache_interface.py,sha256=244uTVx83hpCpbCDgEOydi5HqG7hKHHzEoz1ApJW6lI,14627
+cache_dit/cache_factory/cache_interface.py,sha256=_7RSugGxNArLP2i3qmfq-hon_OTPCz3DSZbwQoCemcc,16558
 cache_dit/cache_factory/cache_types.py,sha256=QnWfaS52UOXQtnoCUOwwz4ziY0dyBta6vQ6hvgtdV44,1404
 cache_dit/cache_factory/forward_pattern.py,sha256=FumlCuZ-TSmSYH0hGBHctSJ-oGLCftdZjLygqhsmdR4,2258
 cache_dit/cache_factory/params_modifier.py,sha256=2T98IbepAolWW6GwQsqUDsRzu0k65vo7BOrN3V8mKog,3606
 cache_dit/cache_factory/utils.py,sha256=S3SD6Zhexzhkqnmfo830v6oNLm8stZe32nF4VdxD_bA,2497
 cache_dit/cache_factory/block_adapters/__init__.py,sha256=eeBcWUMIvS-x3GcD1LNesW2SuB9V5mtwG9MoUBWHsL8,19765
-cache_dit/cache_factory/block_adapters/block_adapters.py,sha256=2TVK_KqiYXC7AKZ2s07fzdOzUoeUBc9P1SzQtLVzhf4,22249
-cache_dit/cache_factory/block_adapters/block_registers.py,sha256=KU0cqtLYRlij2WvuQ6erqZbxUWkb6DjvmY_sB3o_fQM,2594
+cache_dit/cache_factory/block_adapters/block_adapters.py,sha256=hnHZbM3UCIk1fb8HS8Z42w7kJ76xNIl36thONSjkT4g,23267
+cache_dit/cache_factory/block_adapters/block_registers.py,sha256=NvzeeBM32pxuUymcyNibcTgX-9UnnDTRt8_zTXcci6c,2591
 cache_dit/cache_factory/cache_adapters/__init__.py,sha256=py71WGD3JztQ1uk6qdLVbzYcQ1rvqFidNNaQYo7tqTo,79
-cache_dit/cache_factory/cache_adapters/cache_adapter.py,sha256=WYrgV3DKxOxttl-wEKymyKIB1Po0eW73Q2_vOlGEKdQ,24080
+cache_dit/cache_factory/cache_adapters/cache_adapter.py,sha256=_TfI4c-evcxP3mngiPhWYoVoOJ-q4xVGEqukGhZ7b0w,24270
 cache_dit/cache_factory/cache_blocks/__init__.py,sha256=cpxzmDcUhbXcReHqaKSnWyEEbIg1H91Pz5hE3z9Xj3k,9984
 cache_dit/cache_factory/cache_blocks/offload_utils.py,sha256=wusgcqaCrwEjvv7Guy-6VXhNOgPPUrBV2sSVuRmGuvo,3513
 cache_dit/cache_factory/cache_blocks/pattern_0_1_2.py,sha256=j4bTafqU5DLQhzP_X5XwOk-QUVLWkGrX-Q6JZvBGHh0,666
@@ -54,17 +54,17 @@ cache_dit/metrics/lpips.py,sha256=hrHrmdM-f2B4TKDs0xLqJO5JFaYcCjq2qNIR8oCrVkc,81
 cache_dit/metrics/metrics.py,sha256=AZbQyoavE-djvyRUZ_EfCIrWSQbiWQFo7n2dhn7XptE,40466
 cache_dit/parallelism/__init__.py,sha256=dheBG5_TZCuwctviMslpAEgB-B3N8F816bE51qsw_fU,210
 cache_dit/parallelism/parallel_backend.py,sha256=js1soTMenLeAyPMsBgdI3gWcdXoqjWgBD-PuFEywMr0,508
-cache_dit/parallelism/parallel_config.py,sha256=cOAXaniGf4CDPG5sbVktZy2rTZe49jSsnUIW2IBerGM,2106
-cache_dit/parallelism/parallel_interface.py,sha256=WPPYYaodo0PCYrn6-Haz8GcNZ2RK3EG7q6P_cH51Qj0,2202
+cache_dit/parallelism/parallel_config.py,sha256=ZGCWsSu4LcBsjZ2h8NACHhw8WYi_oSqJbZaZIRdQl1Q,2120
+cache_dit/parallelism/parallel_interface.py,sha256=8jNzmZdExMl0aKMAJHpYRlYfz3Ex65KzF9ZrHKlHi6Y,2340
 cache_dit/parallelism/backends/native_diffusers/__init__.py,sha256=T_6GeBA7TRiVbvtqGLLH2flkRiK0o7JBREt2xhS_-YE,242
-cache_dit/parallelism/backends/native_diffusers/parallel_difffusers.py,sha256=wHRjxRWK5E92cdSwDkZJpKQCQGZfxY53woW47rMFH2I,2844
+cache_dit/parallelism/backends/native_diffusers/parallel_difffusers.py,sha256=aRwL1lJXOWl9JaJx9XRv391irkN5xFWJiOOIT_1lu0E,3476
 cache_dit/parallelism/backends/native_pytorch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cache_dit/quantize/__init__.py,sha256=rUu0V9VRjOgwXuIUHHAI-osivNjAdUsi-jpkDbFp6Gk,278
 cache_dit/quantize/quantize_ao.py,sha256=bbEUwsrMp3bMuRw8qJZREIvCHaJRQoZyfMjlu4ImRMI,6315
 cache_dit/quantize/quantize_interface.py,sha256=2s_R7xPSKuJeFpEGeLwRxnq_CqJcBG3a3lzyW5wh-UM,1241
-cache_dit-1.0.8.dist-info/licenses/LICENSE,sha256=Dqb07Ik2dV41s9nIdMUbiRWEfDqo7-dQeRiY7kPO8PE,3769
-cache_dit-1.0.8.dist-info/METADATA,sha256=cs6CuqsbXQ8w69_kg2e7yALeczPAZjd5hz8odNrsvZA,29462
-cache_dit-1.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cache_dit-1.0.8.dist-info/entry_points.txt,sha256=FX2gysXaZx6NeK1iCLMcIdP8Q4_qikkIHtEmi3oWn8o,65
-cache_dit-1.0.8.dist-info/top_level.txt,sha256=ZJDydonLEhujzz0FOkVbO-BqfzO9d_VqRHmZU-3MOZo,10
-cache_dit-1.0.8.dist-info/RECORD,,
+cache_dit-1.0.9.dist-info/licenses/LICENSE,sha256=Dqb07Ik2dV41s9nIdMUbiRWEfDqo7-dQeRiY7kPO8PE,3769
+cache_dit-1.0.9.dist-info/METADATA,sha256=ZAjv17YPgYMgNcyONGRh4fuwKIDhxjdOsWJYLJc3y18,29872
+cache_dit-1.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cache_dit-1.0.9.dist-info/entry_points.txt,sha256=FX2gysXaZx6NeK1iCLMcIdP8Q4_qikkIHtEmi3oWn8o,65
+cache_dit-1.0.9.dist-info/top_level.txt,sha256=ZJDydonLEhujzz0FOkVbO-BqfzO9d_VqRHmZU-3MOZo,10
+cache_dit-1.0.9.dist-info/RECORD,,