cache-dit 0.2.25__py3-none-any.whl → 0.2.26__py3-none-any.whl

cache_dit/cache_factory/patch_functors/functor_chroma.py

@@ -0,0 +1,273 @@
+import inspect
+
+import torch
+import numpy as np
+from typing import Tuple, Optional, Dict, Any, Union
+from diffusers import ChromaTransformer2DModel
+from diffusers.models.transformers.transformer_chroma import (
+    ChromaSingleTransformerBlock,
+    Transformer2DModelOutput,
+)
+from diffusers.utils import (
+    USE_PEFT_BACKEND,
+    scale_lora_layers,
+    unscale_lora_layers,
+)
+
+from cache_dit.cache_factory.patch_functors.functor_base import (
+    PatchFunctor,
+)
+from cache_dit.logger import init_logger
+
+logger = init_logger(__name__)
+
+
+class ChromaPatchFunctor(PatchFunctor):
+
+    def apply(
+        self,
+        transformer: ChromaTransformer2DModel,
+        blocks: torch.nn.ModuleList = None,
+        **kwargs,
+    ) -> ChromaTransformer2DModel:
+        if blocks is None:
+            blocks = transformer.single_transformer_blocks
+
+        is_patched = False
+        for block in blocks:
+            if isinstance(block, ChromaSingleTransformerBlock):
+                forward_parameters = inspect.signature(
+                    block.forward
+                ).parameters.keys()
+                if "encoder_hidden_states" not in forward_parameters:
+                    block.forward = __patch_single_forward__.__get__(block)
+                    is_patched = True
+
+        if is_patched:
+            logger.warning("Patched Chroma for cache-dit.")
+            assert not getattr(transformer, "_is_parallelized", False), (
+                "Please call `cache_dit.enable_cache` before Parallelize, "
+                "the __patch_transformer_forward__ will overwrite the "
+                "parallized forward and cause a downgrade of performance."
+            )
+            transformer.forward = __patch_transformer_forward__.__get__(
+                transformer
+            )
+            transformer._is_patched = True
+
+        cls_name = transformer.__class__.__name__
+        logger.info(
+            f"Applied {self.__class__.__name__} for {cls_name}, "
+            f"Patch: {is_patched}."
+        )
+
+        return transformer
+
+
+# adapted from: https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_chroma.py
+def __patch_single_forward__(
+    self: ChromaSingleTransformerBlock,  # Almost same as FluxSingleTransformerBlock
+    hidden_states: torch.Tensor,
+    encoder_hidden_states: torch.Tensor,
+    temb: torch.Tensor,
+    image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+    joint_attention_kwargs: Optional[Dict[str, Any]] = None,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    text_seq_len = encoder_hidden_states.shape[1]
+    hidden_states = torch.cat([encoder_hidden_states, hidden_states], dim=1)
+
+    residual = hidden_states
+    norm_hidden_states, gate = self.norm(hidden_states, emb=temb)
+    mlp_hidden_states = self.act_mlp(self.proj_mlp(norm_hidden_states))
+    joint_attention_kwargs = joint_attention_kwargs or {}
+    attn_output = self.attn(
+        hidden_states=norm_hidden_states,
+        image_rotary_emb=image_rotary_emb,
+        **joint_attention_kwargs,
+    )
+
+    hidden_states = torch.cat([attn_output, mlp_hidden_states], dim=2)
+    gate = gate.unsqueeze(1)
+    hidden_states = gate * self.proj_out(hidden_states)
+    hidden_states = residual + hidden_states
+    if hidden_states.dtype == torch.float16:
+        hidden_states = hidden_states.clip(-65504, 65504)
+
+    encoder_hidden_states, hidden_states = (
+        hidden_states[:, :text_seq_len],
+        hidden_states[:, text_seq_len:],
+    )
+    return encoder_hidden_states, hidden_states
+
+
+# Adapted from: https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_chroma.py
+def __patch_transformer_forward__(
+    self: ChromaTransformer2DModel,
+    hidden_states: torch.Tensor,
+    encoder_hidden_states: torch.Tensor = None,
+    timestep: torch.LongTensor = None,
+    img_ids: torch.Tensor = None,
+    txt_ids: torch.Tensor = None,
+    attention_mask: torch.Tensor = None,
+    joint_attention_kwargs: Optional[Dict[str, Any]] = None,
+    controlnet_block_samples=None,
+    controlnet_single_block_samples=None,
+    return_dict: bool = True,
+    controlnet_blocks_repeat: bool = False,
+) -> Union[torch.Tensor, Transformer2DModelOutput]:
+    if joint_attention_kwargs is not None:
+        joint_attention_kwargs = joint_attention_kwargs.copy()
+        lora_scale = joint_attention_kwargs.pop("scale", 1.0)
+    else:
+        lora_scale = 1.0
+
+    if USE_PEFT_BACKEND:
+        # weight the lora layers by setting `lora_scale` for each PEFT layer
+        scale_lora_layers(self, lora_scale)
+    else:
+        if (
+            joint_attention_kwargs is not None
+            and joint_attention_kwargs.get("scale", None) is not None
+        ):
+            logger.warning(
+                "Passing `scale` via `joint_attention_kwargs` when not using the PEFT backend is ineffective."
+            )
+
+    hidden_states = self.x_embedder(hidden_states)
+
+    timestep = timestep.to(hidden_states.dtype) * 1000
+
+    input_vec = self.time_text_embed(timestep)
+    pooled_temb = self.distilled_guidance_layer(input_vec)
+
+    encoder_hidden_states = self.context_embedder(encoder_hidden_states)
+
+    if txt_ids.ndim == 3:
+        logger.warning(
+            "Passing `txt_ids` 3d torch.Tensor is deprecated."
+            "Please remove the batch dimension and pass it as a 2d torch Tensor"
+        )
+        txt_ids = txt_ids[0]
+    if img_ids.ndim == 3:
+        logger.warning(
+            "Passing `img_ids` 3d torch.Tensor is deprecated."
+            "Please remove the batch dimension and pass it as a 2d torch Tensor"
+        )
+        img_ids = img_ids[0]
+
+    ids = torch.cat((txt_ids, img_ids), dim=0)
+    image_rotary_emb = self.pos_embed(ids)
+
+    if (
+        joint_attention_kwargs is not None
+        and "ip_adapter_image_embeds" in joint_attention_kwargs
+    ):
+        ip_adapter_image_embeds = joint_attention_kwargs.pop(
+            "ip_adapter_image_embeds"
+        )
+        ip_hidden_states = self.encoder_hid_proj(ip_adapter_image_embeds)
+        joint_attention_kwargs.update({"ip_hidden_states": ip_hidden_states})
+
+    for index_block, block in enumerate(self.transformer_blocks):
+        img_offset = 3 * len(self.single_transformer_blocks)
+        txt_offset = img_offset + 6 * len(self.transformer_blocks)
+        img_modulation = img_offset + 6 * index_block
+        text_modulation = txt_offset + 6 * index_block
+        temb = torch.cat(
+            (
+                pooled_temb[:, img_modulation : img_modulation + 6],
+                pooled_temb[:, text_modulation : text_modulation + 6],
+            ),
+            dim=1,
+        )
+        if torch.is_grad_enabled() and self.gradient_checkpointing:
+            encoder_hidden_states, hidden_states = (
+                self._gradient_checkpointing_func(
+                    block,
+                    hidden_states,
+                    encoder_hidden_states,
+                    temb,
+                    image_rotary_emb,
+                    attention_mask,
+                )
+            )
+
+        else:
+            encoder_hidden_states, hidden_states = block(
+                hidden_states=hidden_states,
+                encoder_hidden_states=encoder_hidden_states,
+                temb=temb,
+                image_rotary_emb=image_rotary_emb,
+                attention_mask=attention_mask,
+                joint_attention_kwargs=joint_attention_kwargs,
+            )
+
+        # controlnet residual
+        if controlnet_block_samples is not None:
+            interval_control = len(self.transformer_blocks) / len(
+                controlnet_block_samples
+            )
+            interval_control = int(np.ceil(interval_control))
+            # For Xlabs ControlNet.
+            if controlnet_blocks_repeat:
+                hidden_states = (
+                    hidden_states
+                    + controlnet_block_samples[
+                        index_block % len(controlnet_block_samples)
+                    ]
+                )
+            else:
+                hidden_states = (
+                    hidden_states
+                    + controlnet_block_samples[index_block // interval_control]
+                )
+
+    for index_block, block in enumerate(self.single_transformer_blocks):
+        start_idx = 3 * index_block
+        temb = pooled_temb[:, start_idx : start_idx + 3]
+        if torch.is_grad_enabled() and self.gradient_checkpointing:
+            encoder_hidden_states, hidden_states = (
+                self._gradient_checkpointing_func(
+                    block,
+                    hidden_states,
+                    encoder_hidden_states,
+                    temb,
+                    image_rotary_emb,
+                )
+            )
+
+        else:
+            encoder_hidden_states, hidden_states = block(
+                hidden_states=hidden_states,
+                encoder_hidden_states=encoder_hidden_states,
+                temb=temb,
+                image_rotary_emb=image_rotary_emb,
+                attention_mask=attention_mask,
+                joint_attention_kwargs=joint_attention_kwargs,
+            )
+
+        # controlnet residual
+        if controlnet_single_block_samples is not None:
+            interval_control = len(self.single_transformer_blocks) / len(
+                controlnet_single_block_samples
+            )
+            interval_control = int(np.ceil(interval_control))
+            hidden_states = (
+                hidden_states
+                + controlnet_single_block_samples[
+                    index_block // interval_control
+                ]
+            )
+
+    temb = pooled_temb[:, -2:]
+    hidden_states = self.norm_out(hidden_states, temb)
+    output = self.proj_out(hidden_states)
+
+    if USE_PEFT_BACKEND:
+        # remove `lora_scale` from each PEFT layer
+        unscale_lora_layers(self, lora_scale)
+
+    if not return_dict:
+        return (output,)
+
+    return Transformer2DModelOutput(sample=output)

cache_dit/cache_factory/{patch/flux.py → patch_functors/functor_flux.py}

@@ -14,12 +14,56 @@ from diffusers.utils import (
     unscale_lora_layers,
 )
 
-
+from cache_dit.cache_factory.patch_functors.functor_base import (
+    PatchFunctor,
+)
 from cache_dit.logger import init_logger
 
 logger = init_logger(__name__)
 
 
+class FluxPatchFunctor(PatchFunctor):
+
+    def apply(
+        self,
+        transformer: FluxTransformer2DModel,
+        blocks: torch.nn.ModuleList = None,
+        **kwargs,
+    ) -> FluxTransformer2DModel:
+        if blocks is None:
+            blocks = transformer.single_transformer_blocks
+
+        is_patched = False
+        for block in blocks:
+            if isinstance(block, FluxSingleTransformerBlock):
+                forward_parameters = inspect.signature(
+                    block.forward
+                ).parameters.keys()
+                if "encoder_hidden_states" not in forward_parameters:
+                    block.forward = __patch_single_forward__.__get__(block)
+                    is_patched = True
+
+        if is_patched:
+            logger.warning("Patched Flux for cache-dit.")
+            assert not getattr(transformer, "_is_parallelized", False), (
+                "Please call `cache_dit.enable_cache` before Parallelize, "
+                "the __patch_transformer_forward__ will overwrite the "
+                "parallized forward and cause a downgrade of performance."
+            )
+            transformer.forward = __patch_transformer_forward__.__get__(
+                transformer
+            )
+            transformer._is_patched = True
+
+        cls_name = transformer.__class__.__name__
+        logger.info(
+            f"Applied {self.__class__.__name__} for {cls_name}, "
+            f"Patch: {is_patched}."
+        )
+
+        return transformer
+
+
 # copy from: https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_flux.py#L380
 def __patch_single_forward__(
     self: FluxSingleTransformerBlock,
@@ -217,33 +261,3 @@ def __patch_transformer_forward__(
         return (output,)
 
     return Transformer2DModelOutput(sample=output)
-
-
-def maybe_patch_flux_transformer(
-    transformer: FluxTransformer2DModel,
-    blocks: torch.nn.ModuleList = None,
-) -> FluxTransformer2DModel:
-    if blocks is None:
-        blocks = transformer.single_transformer_blocks
-
-    is_patched = False
-    for block in blocks:
-        if isinstance(block, FluxSingleTransformerBlock):
-            forward_parameters = inspect.signature(
-                block.forward
-            ).parameters.keys()
-            if "encoder_hidden_states" not in forward_parameters:
-                block.forward = __patch_single_forward__.__get__(block)
-                is_patched = True
-
-    if is_patched:
-        logger.warning("Patched Flux for cache-dit.")
-        assert not getattr(transformer, "_is_parallelized", False), (
-            "Please call apply_cache_on_pipe before Parallelize, "
-            "the __patch_transformer_forward__ will overwrite the "
-            "parallized forward and cause a downgrade of performance."
-        )
-        transformer.forward = __patch_transformer_forward__.__get__(transformer)
-        transformer._is_patched = True
-
-    return transformer

cache_dit/quantize/quantize_ao.py

@@ -10,12 +10,13 @@ logger = init_logger(__name__)
 def quantize_ao(
     module: torch.nn.Module,
     quant_type: str = "fp8_w8a8_dq",
-    per_row: bool = True,
     exclude_layers: List[str] = [
         "embedder",
         "embed",
     ],
     filter_fn: Optional[Callable] = None,
+    # paramters for fp8 quantization
+    per_row: bool = True,
     **kwargs,
 ) -> torch.nn.Module:
     # Apply FP8 DQ for module and skip any `embed` modules
@@ -89,17 +90,30 @@ def quantize_ao(
                 )
 
                 quantization_fn = float8_dynamic_activation_float8_weight(
+                    weight_dtype=kwargs.get(
+                        "weight_dtype",
+                        torch.float8_e4m3fn,
+                    ),
+                    activation_dtype=kwargs.get(
+                        "activation_dtype",
+                        torch.float8_e4m3fn,
+                    ),
                     granularity=(
                         ((PerRow(), PerRow()))
                         if per_row
                         else ((PerTensor(), PerTensor()))
-                    )
+                    ),
                 )
 
             elif quant_type == "fp8_w8a16_wo":
                 from torchao.quantization import float8_weight_only
 
-                quantization_fn = float8_weight_only()
+                quantization_fn = float8_weight_only(
+                    weight_dtype=kwargs.get(
+                        "weight_dtype",
+                        torch.float8_e4m3fn,
+                    ),
+                )
 
             elif quant_type == "int8_w8a8_dq":
                 from torchao.quantization import (
@@ -159,7 +173,7 @@ def quantize_ao(
         module,
         _quantization_fn(),
         filter_fn=_filter_fn if filter_fn is None else filter_fn,
-        **kwargs,
+        device=kwargs.get("device", None),
     )
 
     force_empty_cache()

cache_dit/quantize/quantize_interface.py

@@ -9,13 +9,13 @@ def quantize(
     module: torch.nn.Module,
     quant_type: str = "fp8_w8a8_dq",
     backend: str = "ao",
-    # only for fp8_w8a8_dq
-    per_row: bool = True,
     exclude_layers: List[str] = [
         "embedder",
         "embed",
     ],
     filter_fn: Optional[Callable] = None,
+    # only for fp8_w8a8_dq
+    per_row: bool = True,
     **kwargs,
 ) -> torch.nn.Module:
     assert isinstance(module, torch.nn.Module)

cache_dit/utils.py

@@ -30,13 +30,14 @@ class CacheStats:
 
 
 def summary(
-    pipe_or_transformer: DiffusionPipeline | torch.nn.Module,
+    pipe_or_transformer: DiffusionPipeline | torch.nn.Module | Any,
     details: bool = False,
     logging: bool = True,
 ) -> CacheStats:
     cache_stats = CacheStats()
     cls_name = pipe_or_transformer.__class__.__name__
-    if isinstance(pipe_or_transformer, DiffusionPipeline):
+    if not isinstance(pipe_or_transformer, torch.nn.Module):
+        assert hasattr(pipe_or_transformer, "transformer")
         transformer = pipe_or_transformer.transformer
     else:
         transformer = pipe_or_transformer

{cache_dit-0.2.25.dist-info → cache_dit-0.2.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cache_dit
-Version: 0.2.25
+Version: 0.2.26
 Summary: 🤗 CacheDiT: An Unified and Training-free Cache Acceleration Toolbox for Diffusion Transformers
 Author: DefTruth, vipshop.com, etc.
 Maintainer: DefTruth, vipshop.com, etc
@@ -59,16 +59,17 @@ Dynamic: requires-python
   🔥<b><a href="#unified">Unified Cache APIs</a> | <a href="#dbcache">DBCache</a> | <a href="#taylorseer">Hybrid TaylorSeer</a> | <a href="#cfg">Hybrid Cache CFG</a></b>🔥
   </p>
   <p align="center">
-  🎉Now, <b>cache-dit</b> covers <b>Most</b> mainstream <b>Diffusers'</b> Pipelines</b>🎉<br>
+  🎉Now, <b>cache-dit</b> covers <b>All</b> mainstream <b>DiT-based</b> Diffusers' Pipelines</b>🎉<br>
   🔥<b><a href="#supported">Qwen-Image</a> | <a href="#supported">FLUX.1</a> | <a href="#supported">Wan 2.1/2.2</a> | <a href="#supported"> ... </a> | <a href="#supported">CogVideoX</a></b>🔥
   </p>
 </div>
 
 ## 🔥News  
 
-- [2025-08-26] 🎉[**Wan2.2**](https://github.com/Wan-Video) **1.8x⚡️** speedup with `cache-dit + compile`! Check the [example](./examples/run_wan_2.2.py).
-- [2025-08-19] 🔥[**Qwen-Image-Edit**](https://github.com/QwenLM/Qwen-Image) **2x⚡️** speedup! Check example [run_qwen_image_edit.py](./examples/run_qwen_image_edit.py).
-- [2025-08-12] 🎉First caching mechanism in [QwenLM/Qwen-Image](https://github.com/QwenLM/Qwen-Image) with **[cache-dit](https://github.com/vipshop/cache-dit)**, check the [PR](https://github.com/QwenLM/Qwen-Image/pull/61). 
+- [2025-08-29] 🔥</b>Covers <b>All</b> Diffusers' <b>DiT-based</b> Pipelines via **[BlockAdapter](#unified) + [Pattern Matching](#unified).**
+- [2025-08-26] 🎉[**Wan2.2**](https://github.com/Wan-Video) **1.8x⚡️** speedup with `cache-dit + compile`! Please check the [example](./examples/run_wan_2.2.py).
+- [2025-08-19] 🔥[**Qwen-Image-Edit**](https://github.com/QwenLM/Qwen-Image) **2x⚡️** speedup! Check the example at [run_qwen_image_edit.py](./examples/run_qwen_image_edit.py).
+- [2025-08-12] 🎉First caching mechanism in [QwenLM/Qwen-Image](https://github.com/QwenLM/Qwen-Image) with **[cache-dit](https://github.com/vipshop/cache-dit)**, check this [PR](https://github.com/QwenLM/Qwen-Image/pull/61). 
 - [2025-08-11] 🔥[**Qwen-Image**](https://github.com/QwenLM/Qwen-Image) **1.8x⚡️** speedup! Please refer [run_qwen_image.py](./examples/run_qwen_image.py) as an example.
 
 <details>
@@ -79,7 +80,7 @@ Dynamic: requires-python
 - [2025-07-13] **[🤗flux-faster](https://github.com/xlite-dev/flux-faster)** is released! **3.3x** speedup for FLUX.1 on NVIDIA L20 with **[cache-dit](https://github.com/vipshop/cache-dit)**.
 
 </details>
- 
+
 ## 📖Contents 
 
 <div id="contents"></div>  
@@ -112,8 +113,19 @@ pip3 install git+https://github.com/vipshop/cache-dit.git
 
 <div id="supported"></div>
 
+```python
+>>> import cache_dit
+>>> cache_dit.supported_pipelines()
+(31, ['Flux*', 'Mochi*', 'CogVideoX*', 'Wan*', 'HunyuanVideo*', 'QwenImage*', 'LTXVideo*', 
+'Allegro*', 'CogView3Plus*', 'CogView4*', 'Cosmos*', 'EasyAnimate*', 'SkyReelsV2*', 'SD3*', 
+'ConsisID*', 'DiT*', 'Amused*', 'Bria*', 'HunyuanDiT*', 'HunyuanDiTPAG*', 'Lumina*', 'Lumina2*',
+'OmniGen*', 'PixArt*', 'Sana*', 'ShapE*', 'StableAudio*', 'VisualCloze*', 'AuraFlow*', 
+'Chroma*', 'HiDream*'])
+```
+
 Currently, **cache-dit** library supports almost **Any** Diffusion Transformers (with **Transformer Blocks** that match the specific Input and Output **patterns**). Please check [🎉Unified Cache APIs](#unified) for more details. Here are just some of the tested models listed:
 
+
 - [🚀Qwen-Image-Edit](https://github.com/vipshop/cache-dit/raw/main/examples)  
 - [🚀Qwen-Image](https://github.com/vipshop/cache-dit/raw/main/examples)  
 - [🚀FLUX.1-dev](https://github.com/vipshop/cache-dit/raw/main/examples)  
@@ -125,6 +137,7 @@ Currently, **cache-dit** library supports almost **Any** Diffusion Transformers
 - [🚀Wan2.1-T2V](https://github.com/vipshop/cache-dit/raw/main/examples)
 - [🚀Wan2.1-FLF2V](https://github.com/vipshop/cache-dit/raw/main/examples)
 - [🚀HunyuanVideo](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀HunyuanDiT](https://github.com/vipshop/cache-dit/raw/main/examples)
 
 <details>
 <summary> More Pipelines </summary>  
@@ -138,6 +151,20 @@ Currently, **cache-dit** library supports almost **Any** Diffusion Transformers
 - [🚀EasyAnimate](https://github.com/vipshop/cache-dit/raw/main/examples)
 - [🚀SkyReelsV2](https://github.com/vipshop/cache-dit/raw/main/examples)
 - [🚀SD3](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀ConsisID](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀DiT](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀Amused](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀HunyuanDiTPAG](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀Lumina](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀Lumina2](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀OmniGen](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀PixArt](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀Sana](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀StableAudio](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀VisualCloze](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀AuraFlow](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀Chroma](https://github.com/vipshop/cache-dit/raw/main/examples)
+- [🚀HiDream](https://github.com/vipshop/cache-dit/raw/main/examples)
   
 </details>
 
@@ -330,8 +357,8 @@ cache_dit.enable_cache(
     # For model that fused CFG and non-CFG into single forward step,
     # should set do_separate_cfg as False. For example, set it as True 
     # for Wan 2.1/Qwen-Image and set it as False for FLUX.1, HunyuanVideo, 
-    # CogVideoX, Mochi, etc.
-    do_separate_cfg=True, # Wan 2.1, Qwen-Image
+    # CogVideoX, Mochi, LTXVideo, Allegro, CogView3Plus, EasyAnimate, SD3, etc.
+    do_separate_cfg=True, # Wan 2.1, Qwen-Image, CogView4, Cosmos, SkyReelsV2, etc.
     # Compute cfg forward first or not, default False, namely, 
     # 0, 2, 4, ..., -> non-CFG step; 1, 3, 5, ... -> CFG step.
     cfg_compute_first=False,

cache_dit-0.2.26.dist-info/RECORD

@@ -0,0 +1,42 @@
+cache_dit/__init__.py,sha256=6_DrKjVU0N7BpQLz4A5-qLLmpc4plflHbBAss_4FmC8,1140
+cache_dit/_version.py,sha256=qaUIn8np9pb6UE7Q3omOIYbBHqbmKse_sogKIKw72sA,706
+cache_dit/logger.py,sha256=0zsu42hN-3-rgGC_C29ms1IvVpV4_b4_SwJCKSenxBE,4304
+cache_dit/utils.py,sha256=H4YqlkvenlBxh2-ilOflbVDFqhI1UtnFniDgQac-D6k,7303
+cache_dit/cache_factory/.gitignore,sha256=5Cb-qT9wsTUoMJ7vACDF7ZcLpAXhi5v-xdcWSRit988,23
+cache_dit/cache_factory/__init__.py,sha256=sHGxoYnUWy4CqWTTnrqF2JdleYGdtN7T3erz__zztzE,635
+cache_dit/cache_factory/cache_adapters.py,sha256=NAM7Zo7WrdSb7WOUG2WFRkFXmSx9sXm2oTMx4PhtlZk,39302
+cache_dit/cache_factory/cache_context.py,sha256=krIPLYExwRbwZBj4-eVLV-v5QSEQoVqoLFMZBFWIIT0,41874
+cache_dit/cache_factory/cache_interface.py,sha256=1lCoN1Co1J6lqRI3mDikgqbscWnZShmEw53uatTHJdc,8588
+cache_dit/cache_factory/cache_types.py,sha256=FIFa6ZBfvvSMMHyBBhvarvgg2Y2wbRgITcG_uGylGe0,991
+cache_dit/cache_factory/forward_pattern.py,sha256=FumlCuZ-TSmSYH0hGBHctSJ-oGLCftdZjLygqhsmdR4,2258
+cache_dit/cache_factory/taylorseer.py,sha256=etSUIZzDvqW3ScKCbccTPcFaSmxV1T-xAXdk-p3e3wk,3802
+cache_dit/cache_factory/utils.py,sha256=XkVM9AXcB9zYq8-S8QKAsGz80r3tA6U3lBNGDGeHOe4,1871
+cache_dit/cache_factory/cache_blocks/__init__.py,sha256=jxO8v6o-Ke30HGfnDfZNZ6XknP3sabA2tlHiBW2BZTo,815
+cache_dit/cache_factory/cache_blocks/pattern_0_1_2.py,sha256=dSVcjHPkjlAqLaXxCyvcx8jdFFq6UfIhZk0geziQCVE,434
+cache_dit/cache_factory/cache_blocks/pattern_3_4_5.py,sha256=IMfm3HPzCbQC_SHbn74pfri4zwmPKBgpnT_NhdLxRZs,9598
+cache_dit/cache_factory/cache_blocks/pattern_base.py,sha256=_B1PPICBkyLUoHYWo0XmtIDv944bGBWFSN9y3X9uKTM,18739
+cache_dit/cache_factory/cache_blocks/utils.py,sha256=3VeCcqsYhD719uakrKJNSIFUa0-Qqgw08uu0LCKFa_A,648
+cache_dit/cache_factory/patch_functors/__init__.py,sha256=yK05iONMGILsTZ83ynrUUJtiJKJ_FDjxmVIzRLy416s,252
+cache_dit/cache_factory/patch_functors/functor_base.py,sha256=Ahk0fTfrHgNdEl-9JSkACvfyyv9G-Ei5OSz7XBIlX5o,357
+cache_dit/cache_factory/patch_functors/functor_chroma.py,sha256=RcN6AmpDp19ILY37tjOANlwXHrcaNMHlbv9XWF8hBwA,9942
+cache_dit/cache_factory/patch_functors/functor_flux.py,sha256=ycAypjJ34Uh7hmvbRbHadswRQj_fpxU24YfX1vtBL6c,9450
+cache_dit/compile/__init__.py,sha256=FcTVzCeyypl-mxlc59_ehHL3lBNiDAFsXuRoJ-5Cfi0,56
+cache_dit/compile/utils.py,sha256=nN2OIrSdwRR5zGxJinKDqb07pXpvTNTF3g_OgLkeeBU,3858
+cache_dit/custom_ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cache_dit/custom_ops/triton_taylorseer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cache_dit/metrics/__init__.py,sha256=RaUhl5dieF40RqnizGzR30qoJJ9dyMUEADwgwMaMQrE,575
+cache_dit/metrics/config.py,sha256=ieOgD9ayz722RjVzk24bSIqS2D6o7TZjGk8KeXV-OLQ,551
+cache_dit/metrics/fid.py,sha256=9Ivtazl6mW0Bon2VXa-Ia5Xj2ewxRD3V1Qkd69zYM3Y,17066
+cache_dit/metrics/inception.py,sha256=pBVe2X6ylLPIXTG4-GWDM9DWnCviMJbJ45R3ulhktR0,12759
+cache_dit/metrics/lpips.py,sha256=I2qCNi6qJh5TRsaIsdxO0WoRX1DN7U_H3zS0oCSahYM,1032
+cache_dit/metrics/metrics.py,sha256=8jvM1sF-nDxUuwCRy44QEoo4dYVLCQVh1QyAMs4eaQY,27840
+cache_dit/quantize/__init__.py,sha256=kWYoMAyZgBXu9BJlZjTQ0dRffW9GqeeY9_iTkXrb70A,59
+cache_dit/quantize/quantize_ao.py,sha256=x9zm7AX9JjNhh7mqMkjHDGz2rDl4PzBwwU-CP1e_AVA,6012
+cache_dit/quantize/quantize_interface.py,sha256=2s_R7xPSKuJeFpEGeLwRxnq_CqJcBG3a3lzyW5wh-UM,1241
+cache_dit/quantize/quantize_svdq.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cache_dit-0.2.26.dist-info/licenses/LICENSE,sha256=Dqb07Ik2dV41s9nIdMUbiRWEfDqo7-dQeRiY7kPO8PE,3769
+cache_dit-0.2.26.dist-info/METADATA,sha256=xBljGjnEV9OxSWLRmKx-FLWKUw2DGIv3pNJHg106uOo,21722
+cache_dit-0.2.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cache_dit-0.2.26.dist-info/entry_points.txt,sha256=FX2gysXaZx6NeK1iCLMcIdP8Q4_qikkIHtEmi3oWn8o,65
+cache_dit-0.2.26.dist-info/top_level.txt,sha256=ZJDydonLEhujzz0FOkVbO-BqfzO9d_VqRHmZU-3MOZo,10
+cache_dit-0.2.26.dist-info/RECORD,,

cache_dit-0.2.25.dist-info/RECORD

@@ -1,36 +0,0 @@
-cache_dit/__init__.py,sha256=VsT0f0R0COp8v6Sx9hGNsqxiElERaDpfG11a9MfK0is,945
-cache_dit/_version.py,sha256=t9iixyDuMWz1nP7KM0bgrLNIpwu8JK6uZApA8DoCQwM,706
-cache_dit/logger.py,sha256=0zsu42hN-3-rgGC_C29ms1IvVpV4_b4_SwJCKSenxBE,4304
-cache_dit/utils.py,sha256=1oWDMYs6E7FRsd8cidsVOPT-meIRKeuqbGbE6CrCUec,7236
-cache_dit/cache_factory/.gitignore,sha256=5Cb-qT9wsTUoMJ7vACDF7ZcLpAXhi5v-xdcWSRit988,23
-cache_dit/cache_factory/__init__.py,sha256=evWenCin1kuBGa6W5BCKMrDZc1C1R2uVPSg0BjXgdXE,499
-cache_dit/cache_factory/cache_adapters.py,sha256=Yugqljm9tm615srM2BGQlR_tA0QiZo3PbLPceObh4dQ,25988
-cache_dit/cache_factory/cache_blocks.py,sha256=ZeazBsYvLIjI5M_OnLL2xP2W7zMeM0rxVfBBwIVHBRs,18661
-cache_dit/cache_factory/cache_context.py,sha256=HhA5IMSdF-i-koSB1jqf5AMC_UyDV7VinpHm4Qee9Ig,41800
-cache_dit/cache_factory/cache_interface.py,sha256=HymagnKEDs48Ly_x3IM5jTMNJpLrIdJnppVlkr2xHaM,8433
-cache_dit/cache_factory/cache_types.py,sha256=FIFa6ZBfvvSMMHyBBhvarvgg2Y2wbRgITcG_uGylGe0,991
-cache_dit/cache_factory/forward_pattern.py,sha256=B2YeqV2t_zo2Ar8m7qimPBjwQgoXHGp2grPZmEAhi8s,1286
-cache_dit/cache_factory/taylorseer.py,sha256=etSUIZzDvqW3ScKCbccTPcFaSmxV1T-xAXdk-p3e3wk,3802
-cache_dit/cache_factory/utils.py,sha256=XkVM9AXcB9zYq8-S8QKAsGz80r3tA6U3lBNGDGeHOe4,1871
-cache_dit/cache_factory/patch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cache_dit/cache_factory/patch/flux.py,sha256=iNQ-1RlOgXupZ4uPiEvJ__Ro6vKT_fOKja9JrpMrO78,8998
-cache_dit/compile/__init__.py,sha256=FcTVzCeyypl-mxlc59_ehHL3lBNiDAFsXuRoJ-5Cfi0,56
-cache_dit/compile/utils.py,sha256=nN2OIrSdwRR5zGxJinKDqb07pXpvTNTF3g_OgLkeeBU,3858
-cache_dit/custom_ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cache_dit/custom_ops/triton_taylorseer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cache_dit/metrics/__init__.py,sha256=RaUhl5dieF40RqnizGzR30qoJJ9dyMUEADwgwMaMQrE,575
-cache_dit/metrics/config.py,sha256=ieOgD9ayz722RjVzk24bSIqS2D6o7TZjGk8KeXV-OLQ,551
-cache_dit/metrics/fid.py,sha256=9Ivtazl6mW0Bon2VXa-Ia5Xj2ewxRD3V1Qkd69zYM3Y,17066
-cache_dit/metrics/inception.py,sha256=pBVe2X6ylLPIXTG4-GWDM9DWnCviMJbJ45R3ulhktR0,12759
-cache_dit/metrics/lpips.py,sha256=I2qCNi6qJh5TRsaIsdxO0WoRX1DN7U_H3zS0oCSahYM,1032
-cache_dit/metrics/metrics.py,sha256=8jvM1sF-nDxUuwCRy44QEoo4dYVLCQVh1QyAMs4eaQY,27840
-cache_dit/quantize/__init__.py,sha256=kWYoMAyZgBXu9BJlZjTQ0dRffW9GqeeY9_iTkXrb70A,59
-cache_dit/quantize/quantize_ao.py,sha256=sKz_RmVtxLOpAPnUv_iOjzY_226pfaxgB_HMNrfyqB8,5465
-cache_dit/quantize/quantize_interface.py,sha256=NG4WP7s8CLW6KhVFb9e1aAjW30KWTCcM2aS5n8QuwsA,1241
-cache_dit/quantize/quantize_svdq.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cache_dit-0.2.25.dist-info/licenses/LICENSE,sha256=Dqb07Ik2dV41s9nIdMUbiRWEfDqo7-dQeRiY7kPO8PE,3769
-cache_dit-0.2.25.dist-info/METADATA,sha256=a5wbENMZ9BDjHbM3Ejb7Il7x4QzD8W7Lzmu4poo95Wo,19913
-cache_dit-0.2.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cache_dit-0.2.25.dist-info/entry_points.txt,sha256=FX2gysXaZx6NeK1iCLMcIdP8Q4_qikkIHtEmi3oWn8o,65
-cache_dit-0.2.25.dist-info/top_level.txt,sha256=ZJDydonLEhujzz0FOkVbO-BqfzO9d_VqRHmZU-3MOZo,10
-cache_dit-0.2.25.dist-info/RECORD,,