cache-dit 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

cache_dit/metrics/metrics.py

@@ -0,0 +1,469 @@
+import os
+import cv2
+import pathlib
+import argparse
+import numpy as np
+from tqdm import tqdm
+from functools import partial
+from skimage.metrics import mean_squared_error
+from skimage.metrics import peak_signal_noise_ratio
+from skimage.metrics import structural_similarity
+from cache_dit.metrics.fid import FrechetInceptionDistance
+from cache_dit.metrics.config import set_metrics_verbose
+from cache_dit.metrics.config import get_metrics_verbose
+from cache_dit.metrics.config import _IMAGE_EXTENSIONS
+from cache_dit.metrics.config import _VIDEO_EXTENSIONS
+from cache_dit.logger import init_logger
+
+logger = init_logger(__name__)
+
+
+DISABLE_VERBOSE = not get_metrics_verbose()
+
+
+def compute_psnr_file(
+    image_true: np.ndarray | str,
+    image_test: np.ndarray | str,
+) -> float:
+    """
+    img_true = cv2.imread(img_true_file)
+    img_test = cv2.imread(img_test_file)
+    PSNR = compute_psnr(img_true, img_test)
+    """
+    if isinstance(image_true, str):
+        image_true = cv2.imread(image_true)
+    if isinstance(image_test, str):
+        image_test = cv2.imread(image_test)
+    return peak_signal_noise_ratio(
+        image_true,
+        image_test,
+    )
+
+
+def compute_mse_file(
+    image_true: np.ndarray | str,
+    image_test: np.ndarray | str,
+) -> float:
+    """
+    img_true = cv2.imread(img_true_file)
+    img_test = cv2.imread(img_test_file)
+    MSE = compute_mse(img_true, img_test)
+    """
+    if isinstance(image_true, str):
+        image_true = cv2.imread(image_true)
+    if isinstance(image_test, str):
+        image_test = cv2.imread(image_test)
+    return mean_squared_error(
+        image_true,
+        image_test,
+    )
+
+
+def compute_ssim_file(
+    image_true: np.ndarray | str,
+    image_test: np.ndarray | str,
+) -> float:
+    """
+    img_true = cv2.imread(img_true_file)
+    img_test = cv2.imread(img_test_file)
+    SSIM = compute_ssim(img_true, img_test)
+    """
+    if isinstance(image_true, str):
+        image_true = cv2.imread(image_true)
+    if isinstance(image_test, str):
+        image_test = cv2.imread(image_test)
+    return structural_similarity(
+        image_true,
+        image_test,
+        multichannel=True,
+        channel_axis=2,
+    )
+
+
+def compute_dir_metric(
+    image_true_dir: np.ndarray | str,
+    image_test_dir: np.ndarray | str,
+    compute_file_func: callable = compute_psnr_file,
+) -> float:
+    # Image
+    if isinstance(image_true_dir, np.ndarray) or isinstance(
+        image_test_dir, np.ndarray
+    ):
+        return compute_file_func(image_true_dir, image_test_dir), 1
+    # File
+    if not os.path.isdir(image_true_dir) or not os.path.isdir(image_test_dir):
+        return compute_file_func(image_true_dir, image_test_dir), 1
+    # Dir
+    image_true_dir: pathlib.Path = pathlib.Path(image_true_dir)
+    image_true_files = sorted(
+        [
+            file
+            for ext in _IMAGE_EXTENSIONS
+            for file in image_true_dir.rglob("*.{}".format(ext))
+        ]
+    )
+    image_test_dir: pathlib.Path = pathlib.Path(image_test_dir)
+    image_test_files = sorted(
+        [
+            file
+            for ext in _IMAGE_EXTENSIONS
+            for file in image_test_dir.rglob("*.{}".format(ext))
+        ]
+    )
+    image_true_files = [file.as_posix() for file in image_true_files]
+    image_test_files = [file.as_posix() for file in image_test_files]
+
+    # select valid files
+    image_true_files_selected = []
+    image_test_files_selected = []
+    for i in range(min(len(image_true_files), len(image_test_files))):
+        selected_image_true = image_true_files[i]
+        selected_image_test = image_test_files[i]
+        # Image pair must have the same basename
+        if os.path.basename(selected_image_test) == os.path.basename(
+            selected_image_true
+        ):
+            image_true_files_selected.append(selected_image_true)
+            image_test_files_selected.append(selected_image_test)
+    image_true_files = image_true_files_selected.copy()
+    image_test_files = image_test_files_selected.copy()
+    if len(image_true_files) == 0:
+        logger.error(
+            "No valid Image pairs, please note that Image "
+            "pairs must have the same basename."
+        )
+        return None, None
+
+    logger.debug(f"image_true_files: {image_true_files}")
+    logger.debug(f"image_test_files: {image_test_files}")
+
+    total_metric = 0.0
+    valid_files = 0
+    for image_true, image_test in tqdm(
+        zip(image_true_files, image_test_files),
+        total=len(image_true_files),
+        disable=DISABLE_VERBOSE,
+    ):
+        metric = compute_file_func(image_true, image_test)
+        if metric != float("inf"):
+            total_metric += metric
+            valid_files += 1
+
+    if valid_files > 0:
+        average_metric = total_metric / valid_files
+        logger.debug(f"Average: {average_metric:.2f}")
+        return average_metric, valid_files
+    else:
+        logger.debug("No valid files to compare")
+        return None, None
+
+
+def _fetch_video_frames(
+    video_true: str,
+    video_test: str,
+):
+    cap1 = cv2.VideoCapture(video_true)
+    cap2 = cv2.VideoCapture(video_test)
+
+    if not cap1.isOpened() or not cap2.isOpened():
+        logger.error("Could not open video files")
+        return [], [], 0
+
+    frame_count = min(
+        int(cap1.get(cv2.CAP_PROP_FRAME_COUNT)),
+        int(cap2.get(cv2.CAP_PROP_FRAME_COUNT)),
+    )
+
+    valid_frames = 0
+    video_true_frames = []
+    video_test_frames = []
+
+    logger.debug(f"Total frames: {frame_count}")
+
+    while True:
+        ret1, frame1 = cap1.read()
+        ret2, frame2 = cap2.read()
+
+        if not ret1 or not ret2:
+            break
+
+        video_true_frames.append(frame1)
+        video_test_frames.append(frame2)
+
+        valid_frames += 1
+
+    cap1.release()
+    cap2.release()
+
+    if valid_frames <= 0:
+        return [], [], 0
+
+    return video_true_frames, video_test_frames, valid_frames
+
+
+def compute_video_metric(
+    video_true: str,
+    video_test: str,
+    compute_frame_func: callable = compute_psnr_file,
+) -> float:
+    """
+    video_true = "video_true.mp4"
+    video_test = "video_test.mp4"
+    PSNR = compute_video_psnr(video_true, video_test)
+    """
+    if os.path.isfile(video_true) and os.path.isfile(video_test):
+        video_true_frames, video_test_frames, valid_frames = (
+            _fetch_video_frames(
+                video_true=video_true,
+                video_test=video_test,
+            )
+        )
+    elif os.path.isdir(video_true) and os.path.isdir(video_test):
+        # Glob videos
+        video_true_dir: pathlib.Path = pathlib.Path(video_true)
+        video_true_files = sorted(
+            [
+                file
+                for ext in _VIDEO_EXTENSIONS
+                for file in video_true_dir.rglob("*.{}".format(ext))
+            ]
+        )
+        video_test_dir: pathlib.Path = pathlib.Path(video_test)
+        video_test_files = sorted(
+            [
+                file
+                for ext in _VIDEO_EXTENSIONS
+                for file in video_test_dir.rglob("*.{}".format(ext))
+            ]
+        )
+        video_true_files = [file.as_posix() for file in video_true_files]
+        video_test_files = [file.as_posix() for file in video_test_files]
+
+        # select valid video files
+        video_true_files_selected = []
+        video_test_files_selected = []
+        for i in range(min(len(video_true_files), len(video_test_files))):
+            selected_video_true = video_true_files[i]
+            selected_video_test = video_test_files[i]
+            # Video pair must have the same basename
+            if os.path.basename(selected_video_test) == os.path.basename(
+                selected_video_true
+            ):
+                video_true_files_selected.append(selected_video_true)
+                video_test_files_selected.append(selected_video_test)
+
+        video_true_files = video_true_files_selected.copy()
+        video_test_files = video_test_files_selected.copy()
+        if len(video_true_files) == 0:
+            logger.error(
+                "No valid Video pairs, please note that Video "
+                "pairs must have the same basename."
+            )
+            return None, None
+        logger.debug(f"video_true_files: {video_true_files}")
+        logger.debug(f"video_test_files: {video_test_files}")
+
+        # Fetch all frames
+        video_true_frames = []
+        video_test_frames = []
+        valid_frames = 0
+
+        for video_true_, video_test_ in zip(video_true_files, video_test_files):
+            video_true_frames_, video_test_frames_, valid_frames_ = (
+                _fetch_video_frames(
+                    video_true=video_true_, video_test=video_test_
+                )
+            )
+            video_true_frames.extend(video_true_frames_)
+            video_test_frames.extend(video_test_frames_)
+            valid_frames += valid_frames_
+    else:
+        raise ValueError("video_true and video_test must be files or dirs.")
+
+    if valid_frames <= 0:
+        logger.debug("No valid frames to compare")
+        return None, None
+
+    total_metric = 0.0
+    valid_frames = 0  # reset
+    for frame1, frame2 in tqdm(
+        zip(video_true_frames, video_test_frames),
+        total=len(video_true_frames),
+        disable=DISABLE_VERBOSE,
+    ):
+        metric = compute_frame_func(frame1, frame2)
+        if metric != float("inf"):
+            total_metric += metric
+            valid_frames += 1
+
+    if valid_frames > 0:
+        average_metric = total_metric / valid_frames
+        logger.debug(f"Average: {average_metric:.2f}")
+        return average_metric, valid_frames
+    else:
+        logger.debug("No valid frames to compare")
+        return None, None
+
+
+compute_psnr = partial(
+    compute_dir_metric,
+    compute_file_func=compute_psnr_file,
+)
+
+compute_ssim = partial(
+    compute_dir_metric,
+    compute_file_func=compute_ssim_file,
+)
+
+compute_mse = partial(
+    compute_dir_metric,
+    compute_file_func=compute_mse_file,
+)
+
+compute_video_psnr = partial(
+    compute_video_metric,
+    compute_frame_func=compute_psnr_file,
+)
+compute_video_ssim = partial(
+    compute_video_metric,
+    compute_frame_func=compute_ssim_file,
+)
+compute_video_mse = partial(
+    compute_video_metric,
+    compute_frame_func=compute_mse_file,
+)
+
+
+# Entrypoints
+def get_args():
+    parser = argparse.ArgumentParser(
+        description="CacheDiT's Metrics CLI",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    METRICS_CHOICES = [
+        "psnr",
+        "ssim",
+        "mse",
+        "fid",
+        "all",
+    ]
+    parser.add_argument(
+        "metric",
+        type=str,
+        default="psnr",
+        choices=METRICS_CHOICES,
+        help=f"Metric choices: {METRICS_CHOICES}",
+    )
+    parser.add_argument(
+        "--img-true",
+        "-i1",
+        type=str,
+        default=None,
+        help="Path to ground truth image or Dir to ground truth images",
+    )
+    parser.add_argument(
+        "--img-test",
+        "-i2",
+        type=str,
+        default=None,
+        help="Path to predicted image or Dir to predicted images",
+    )
+    parser.add_argument(
+        "--video-true",
+        "-v1",
+        type=str,
+        default=None,
+        help="Path to ground truth video or Dir to ground truth videos",
+    )
+    parser.add_argument(
+        "--video-test",
+        "-v2",
+        type=str,
+        default=None,
+        help="Path to predicted video or Dir to predicted videos",
+    )
+    parser.add_argument(
+        "--enable-verbose",
+        "-verbose",
+        action="store_true",
+        default=False,
+        help="Show metrics progress verbose",
+    )
+    return parser.parse_args()
+
+
+def entrypoint():
+    args = get_args()
+    logger.debug(args)
+
+    if args.enable_verbose:
+        global DISABLE_VERBOSE
+        set_metrics_verbose(True)
+        DISABLE_VERBOSE = not get_metrics_verbose()
+
+    if args.img_true is not None and args.img_test is not None:
+        if any(
+            (
+                not os.path.exists(args.img_true),
+                not os.path.exists(args.img_test),
+            )
+        ):
+            return
+        # img_true and img_test can be files or dirs
+        if args.metric == "psnr" or args.metric == "all":
+            img_psnr, n = compute_psnr(args.img_true, args.img_test)
+            logger.info(
+                f"{args.img_true} vs {args.img_test}, Num: {n}, PSNR: {img_psnr}"
+            )
+        if args.metric == "ssim" or args.metric == "all":
+            img_ssim, n = compute_ssim(args.img_true, args.img_test)
+            logger.info(
+                f"{args.img_true} vs {args.img_test}, Num: {n}, SSIM: {img_ssim}"
+            )
+        if args.metric == "mse" or args.metric == "all":
+            img_mse, n = compute_mse(args.img_true, args.img_test)
+            logger.info(
+                f"{args.img_true} vs {args.img_test}, Num: {n},  MSE: {img_mse}"
+            )
+        if args.metric == "fid" or args.metric == "all":
+            FID = FrechetInceptionDistance(disable_tqdm=DISABLE_VERBOSE)
+            img_fid, n = FID.compute_fid(args.img_true, args.img_test)
+            logger.info(
+                f"{args.img_true} vs {args.img_test}, Num: {n},  FID: {img_fid}"
+            )
+    if args.video_true is not None and args.video_test is not None:
+        if any(
+            (
+                not os.path.exists(args.video_true),
+                not os.path.exists(args.video_test),
+            )
+        ):
+            return
+        # video_true and video_test can be files or dirs
+        if args.metric == "psnr" or args.metric == "all":
+            video_psnr, n = compute_video_psnr(args.video_true, args.video_test)
+            logger.info(
+                f"{args.video_true} vs {args.video_test}, Frames: {n}, PSNR: {video_psnr}"
+            )
+        if args.metric == "ssim" or args.metric == "all":
+            video_ssim, n = compute_video_ssim(args.video_true, args.video_test)
+            logger.info(
+                f"{args.video_true} vs {args.video_test}, Frames: {n}, SSIM: {video_ssim}"
+            )
+        if args.metric == "mse" or args.metric == "all":
+            video_mse, n = compute_video_mse(args.video_true, args.video_test)
+            logger.info(
+                f"{args.video_true} vs {args.video_test}, Frames: {n},  MSE: {video_mse}"
+            )
+        if args.metric == "fid" or args.metric == "all":
+            FID = FrechetInceptionDistance(disable_tqdm=DISABLE_VERBOSE)
+            video_fid, n = FID.compute_video_fid(
+                args.video_true, args.video_test
+            )
+            logger.info(
+                f"{args.video_true} vs {args.video_test}, Frames: {n},  FID: {video_fid}"
+            )
+
+
+if __name__ == "__main__":
+    entrypoint()

{cache_dit-0.2.5.dist-info → cache_dit-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cache_dit
-Version: 0.2.5
+Version: 0.2.7
 Summary: 🤗 CacheDiT: A Training-free and Easy-to-use Cache Acceleration Toolbox for Diffusion Transformers
 Author: DefTruth, vipshop.com, etc.
 Maintainer: DefTruth, vipshop.com, etc
@@ -13,6 +13,8 @@ Requires-Dist: packaging
 Requires-Dist: torch>=2.5.1
 Requires-Dist: transformers>=4.51.3
 Requires-Dist: diffusers>=0.33.1
+Requires-Dist: scikit-image
+Requires-Dist: scipy
 Provides-Extra: all
 Provides-Extra: dev
 Requires-Dist: pre-commit; extra == "dev"
@@ -28,6 +30,8 @@ Requires-Dist: protobuf; extra == "dev"
 Requires-Dist: sentencepiece; extra == "dev"
 Requires-Dist: opencv-python-headless; extra == "dev"
 Requires-Dist: ftfy; extra == "dev"
+Requires-Dist: scikit-image; extra == "dev"
+Requires-Dist: pytorch-fid; extra == "dev"
 Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
@@ -159,6 +163,7 @@ The **CacheDiT** codebase is adapted from [FBCache](https://github.com/chengzeyi
 - [⚡️Dynamic Block Prune](#dbprune)
 - [🎉Context Parallelism](#context-parallelism)  
 - [🔥Torch Compile](#compile)
+- [⚙️Metrics CLI](#metrics)
 - [👋Contribute](#contribute)
 - [©️License](#license)
 
@@ -500,6 +505,37 @@ torch._dynamo.config.accumulated_recompile_limit = 2048  # default is 256
 
 Please check [bench.py](./bench/bench.py) for more details.
 
+
+## ⚙️Metrics CLI
+
+<div id="metrics"></div>    
+
+You can utilize the APIs provided by CacheDiT to quickly evaluate the accuracy losses caused by different cache configurations. For example:
+
+```python
+from cache_dit.metrics import compute_psnr
+from cache_dit.metrics import compute_video_psnr
+from cache_dit.metrics import FrechetInceptionDistance  # FID
+
+FID = FrechetInceptionDistance()
+image_psnr, n = compute_psnr("true.png", "test.png") # Num: n
+image_fid,  n = FID.compute_fid("true_dir", "test_dir")
+video_psnr, n = compute_video_psnr("true.mp4", "test.mp4") # Frames: n
+```
+
+Please check [test_metrics.py](./tests/test_metrics.py) for more details. Or, you can use `cache-dit-metrics-cli` tool. For examples: 
+
+```bash
+cache-dit-metrics-cli -h  # show usage
+# all: PSNR, FID, SSIM, MSE, ..., etc.
+cache-dit-metrics-cli all  -i1 true.png -i2 test.png  # image
+cache-dit-metrics-cli all  -i1 true_dir -i2 test_dir  # image dir
+cache-dit-metrics-cli all  -v1 true.mp4 -v2 test.mp4  # video
+cache-dit-metrics-cli all  -v1 true_dir -v2 test_dir  # video dir
+cache-dit-metrics-cli fid  -i1 true_dir -i2 test_dir  # FID
+cache-dit-metrics-cli psnr -i1 true_dir -i2 test_dir  # PSNR
+```
+
 ## 👋Contribute 
 <div id="contribute"></div>
 

{cache_dit-0.2.5.dist-info → cache_dit-0.2.7.dist-info}/RECORD

@@ -1,17 +1,17 @@
 cache_dit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cache_dit/_version.py,sha256=N3oBwJUFmS-AwCjqOcSlRW4GvSq-uJJMaBvoGfv1-hM,511
+cache_dit/_version.py,sha256=Xk20v7uvkFqkpy9aLJzVngs1eKQn0FYUP2oyA1MEQUU,511
 cache_dit/logger.py,sha256=0zsu42hN-3-rgGC_C29ms1IvVpV4_b4_SwJCKSenxBE,4304
 cache_dit/primitives.py,sha256=A2iG9YLot3gOsZSPp-_gyjqjLgJvWQRx8aitD4JQ23Y,3877
 cache_dit/cache_factory/__init__.py,sha256=5RNuhWakvvqrOV4vkqrEBA7d-V1LwcNSsjtW14mkqK8,5255
 cache_dit/cache_factory/taylorseer.py,sha256=LKSNo2ode69EVo9xrxjxAMEjz0yDGiGADeDYnEqddA8,3987
 cache_dit/cache_factory/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cache_dit/cache_factory/dual_block_cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cache_dit/cache_factory/dual_block_cache/cache_context.py,sha256=wE_xYp7DRbgB-fD8dpr75o4Cvvl2s-jnT2fRyqWm_RM,71286
+cache_dit/cache_factory/dual_block_cache/cache_context.py,sha256=7kMk6hvMDi-m2HP1qlj4p6qJhzZPjJol6IBneVGDs3E,71396
 cache_dit/cache_factory/dual_block_cache/diffusers_adapters/__init__.py,sha256=krNAICf-aS3JLmSG8vOB9tpLa04uYRcABsC8PMbVUKY,1870
-cache_dit/cache_factory/dual_block_cache/diffusers_adapters/cogvideox.py,sha256=fibkeU-FHa30BNT-uPV2Eqcd5IRli07EKb25tMDp23c,2270
-cache_dit/cache_factory/dual_block_cache/diffusers_adapters/flux.py,sha256=fddSpTHXU24COMGAY-Z21EmHHAEArZBv_-XLRFD6ADU,2625
-cache_dit/cache_factory/dual_block_cache/diffusers_adapters/hunyuan_video.py,sha256=wcZdBhjUB8WSfz40A268BtSe3nr_hRsIi2BNlg1FHRU,9965
-cache_dit/cache_factory/dual_block_cache/diffusers_adapters/mochi.py,sha256=Cmy0KHRDgwXqtmqfkrr7kw0CP6CmkSnuz29gDHcD6sQ,2262
+cache_dit/cache_factory/dual_block_cache/diffusers_adapters/cogvideox.py,sha256=3xUjvDzor9AkBkDUc0N7kZqM86MIdajuigesnicNzXE,2260
+cache_dit/cache_factory/dual_block_cache/diffusers_adapters/flux.py,sha256=cIsov6Pf0dRyddqkzTA2CU-jSDotof8LQr-HIoY9T9M,2615
+cache_dit/cache_factory/dual_block_cache/diffusers_adapters/hunyuan_video.py,sha256=SO4q39PQuQ5QVHy5Z-ubiKdstzvQPedONN2J5oiGUh0,9955
+cache_dit/cache_factory/dual_block_cache/diffusers_adapters/mochi.py,sha256=8W9m-WeEVE2ytYi9udKEA8Wtb0EnvP3eT2A1Tu-d29k,2252
 cache_dit/cache_factory/dual_block_cache/diffusers_adapters/wan.py,sha256=EREHM5E1wxnL-uRXRAEege4HXraRp1oD_r1Zx4CsiKk,2596
 cache_dit/cache_factory/dynamic_block_prune/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cache_dit/cache_factory/dynamic_block_prune/prune_context.py,sha256=so1wGdb8W0ATwrjv7E5IEZLPcobybaY1HJa6hBYlOOQ,34698
@@ -33,8 +33,14 @@ cache_dit/compile/__init__.py,sha256=DfMdPleFFGADXLsr7zXui8BTz_y9futY6rNmNdh9y7k
 cache_dit/compile/utils.py,sha256=KU60xc474Anbj7Y_FLRFmNxEjVYLLXkhbtCLXO7o_Tc,3699
 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-0.2.5.dist-info/licenses/LICENSE,sha256=Dqb07Ik2dV41s9nIdMUbiRWEfDqo7-dQeRiY7kPO8PE,3769
-cache_dit-0.2.5.dist-info/METADATA,sha256=J37Waq-cMbuFfTrngXuxqouXpjHK9qhR_MZHlE2odmY,26249
-cache_dit-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cache_dit-0.2.5.dist-info/top_level.txt,sha256=ZJDydonLEhujzz0FOkVbO-BqfzO9d_VqRHmZU-3MOZo,10
-cache_dit-0.2.5.dist-info/RECORD,,
+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/metrics.py,sha256=tzAtG_-fM1xPIBfRVFIBupvOWYzIO3xDq29Vy5rOBWc,14730
+cache_dit-0.2.7.dist-info/licenses/LICENSE,sha256=Dqb07Ik2dV41s9nIdMUbiRWEfDqo7-dQeRiY7kPO8PE,3769
+cache_dit-0.2.7.dist-info/METADATA,sha256=S0C1VGcXoWVjxmfX_755xttdoE9J0toSuHCZW9xaUBM,27608
+cache_dit-0.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cache_dit-0.2.7.dist-info/entry_points.txt,sha256=FX2gysXaZx6NeK1iCLMcIdP8Q4_qikkIHtEmi3oWn8o,65
+cache_dit-0.2.7.dist-info/top_level.txt,sha256=ZJDydonLEhujzz0FOkVbO-BqfzO9d_VqRHmZU-3MOZo,10
+cache_dit-0.2.7.dist-info/RECORD,,

cache_dit-0.2.7.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cache-dit-metrics-cli = cache_dit.metrics:main