valor-lite 0.33.6__py3-none-any.whl → 0.33.8__py3-none-any.whl

valor_lite/segmentation/manager.py

@@ -0,0 +1,532 @@
+from collections import defaultdict
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import NDArray
+from tqdm import tqdm
+from valor_lite.segmentation.annotation import Segmentation
+from valor_lite.segmentation.computation import (
+    compute_intermediate_confusion_matrices,
+    compute_metrics,
+)
+from valor_lite.segmentation.metric import (
+    F1,
+    Accuracy,
+    ConfusionMatrix,
+    IoU,
+    MetricType,
+    Precision,
+    Recall,
+    mIoU,
+)
+
+"""
+Usage
+-----
+
+manager = DataLoader()
+manager.add_data(
+    groundtruths=groundtruths,
+    predictions=predictions,
+)
+evaluator = manager.finalize()
+
+metrics = evaluator.evaluate()
+
+f1_metrics = metrics[MetricType.F1]
+accuracy_metrics = metrics[MetricType.Accuracy]
+
+filter_mask = evaluator.create_filter(datum_uids=["uid1", "uid2"])
+filtered_metrics = evaluator.evaluate(filter_mask=filter_mask)
+"""
+
+
+@dataclass
+class Filter:
+    indices: NDArray[np.int32]
+    label_metadata: NDArray[np.int32]
+    n_pixels: int
+
+
+class Evaluator:
+    """
+    Segmentation Evaluator
+    """
+
+    def __init__(self):
+
+        # metadata
+        self.n_datums = 0
+        self.n_groundtruths = 0
+        self.n_predictions = 0
+        self.n_pixels = 0
+        self.n_groundtruth_pixels = 0
+        self.n_prediction_pixels = 0
+        self.n_labels = 0
+
+        # datum reference
+        self.uid_to_index: dict[str, int] = dict()
+        self.index_to_uid: dict[int, str] = dict()
+
+        # label reference
+        self.label_to_index: dict[str, int] = dict()
+        self.index_to_label: dict[int, str] = dict()
+
+        # computation caches
+        self._confusion_matrices = np.array([])
+        self._label_metadata = np.array([], dtype=np.int32)
+        self._label_metadata_per_datum = np.array([], dtype=np.int32)
+        self._n_pixels_per_datum = np.array([], dtype=np.int32)
+
+    @property
+    def ignored_prediction_labels(self) -> list[str]:
+        """
+        Prediction labels that are not present in the ground truth set.
+        """
+        glabels = set(np.where(self._label_metadata[:, 0] > 0)[0])
+        plabels = set(np.where(self._label_metadata[:, 1] > 0)[0])
+        return [
+            self.index_to_label[label_id] for label_id in (plabels - glabels)
+        ]
+
+    @property
+    def missing_prediction_labels(self) -> list[str]:
+        """
+        Ground truth labels that are not present in the prediction set.
+        """
+        glabels = set(np.where(self._label_metadata[:, 0] > 0)[0])
+        plabels = set(np.where(self._label_metadata[:, 1] > 0)[0])
+        return [
+            self.index_to_label[label_id] for label_id in (glabels - plabels)
+        ]
+
+    @property
+    def metadata(self) -> dict:
+        """
+        Evaluation metadata.
+        """
+        return {
+            "number_of_datums": self.n_datums,
+            "number_of_groundtruths": self.n_groundtruths,
+            "number_of_predictions": self.n_predictions,
+            "number_of_groundtruth_pixels": self.n_groundtruth_pixels,
+            "number_of_prediction_pixels": self.n_prediction_pixels,
+            "number_of_labels": self.n_labels,
+            "ignored_prediction_labels": self.ignored_prediction_labels,
+            "missing_prediction_labels": self.missing_prediction_labels,
+        }
+
+    def create_filter(
+        self,
+        datum_uids: list[str] | NDArray[np.int32] | None = None,
+        labels: list[str] | NDArray[np.int32] | None = None,
+    ) -> Filter:
+        """
+        Creates a boolean mask that can be passed to an evaluation.
+
+        Parameters
+        ----------
+        datum_uids : list[str] | NDArray[np.int32], optional
+            An optional list of string uids or a numpy array of uid indices.
+        labels : list[tuple[str, str]] | NDArray[np.int32], optional
+            An optional list of labels or a numpy array of label indices.
+
+        Returns
+        -------
+        Filter
+            A filter object that can be passed to the `evaluate` method.
+        """
+        n_datums = self._label_metadata_per_datum.shape[1]
+        n_labels = self._label_metadata_per_datum.shape[2]
+
+        mask_datums = np.ones(n_datums, dtype=np.bool_)
+        mask_labels = np.ones(n_labels, dtype=np.bool_)
+
+        if datum_uids is not None:
+            if isinstance(datum_uids, list):
+                datum_uids = np.array(
+                    [self.uid_to_index[uid] for uid in datum_uids],
+                    dtype=np.int32,
+                )
+            if datum_uids.size == 0:
+                mask_datums[mask_datums] = False
+            else:
+                mask = (
+                    np.arange(n_datums).reshape(-1, 1)
+                    == datum_uids.reshape(1, -1)
+                ).any(axis=1)
+                mask_datums[~mask] = False
+
+        if labels is not None:
+            if isinstance(labels, list):
+                labels = np.array(
+                    [self.label_to_index[label] for label in labels],
+                    dtype=np.int32,
+                )
+            if labels.size == 0:
+                mask_labels[mask_labels] = False
+            else:
+                mask = (
+                    np.arange(n_labels).reshape(-1, 1) == labels.reshape(1, -1)
+                ).any(axis=1)
+                mask_labels[~mask] = False
+
+        mask = mask_datums[:, np.newaxis] & mask_labels[np.newaxis, :]
+        label_metadata_per_datum = self._label_metadata_per_datum.copy()
+        label_metadata_per_datum[:, ~mask] = 0
+
+        label_metadata = np.zeros_like(self._label_metadata, dtype=np.int32)
+        label_metadata = np.transpose(
+            np.sum(
+                label_metadata_per_datum,
+                axis=1,
+            )
+        )
+        n_datums = int(np.sum(label_metadata[:, 0]))
+
+        return Filter(
+            indices=np.where(mask_datums)[0],
+            label_metadata=label_metadata,
+            n_pixels=self._n_pixels_per_datum[mask_datums].sum(),
+        )
+
+    def evaluate(
+        self,
+        metrics_to_return: list[MetricType] = MetricType.base(),
+        filter_: Filter | None = None,
+        as_dict: bool = False,
+    ) -> dict[MetricType, list]:
+        """
+        Performs an evaluation and returns metrics.
+
+        Parameters
+        ----------
+        metrics_to_return : list[MetricType]
+            A list of metrics to return in the results.
+        filter_ : Filter, optional
+            An optional filter object.
+
+        Returns
+        -------
+        dict[MetricType, list]
+            A dictionary mapping MetricType enumerations to lists of computed metrics.
+        """
+
+        # apply filters
+        data = self._confusion_matrices
+        label_metadata = self._label_metadata
+        n_pixels = self.n_pixels
+        if filter_ is not None:
+            data = data[filter_.indices]
+            label_metadata = filter_.label_metadata
+            n_pixels = filter_.n_pixels
+
+        (
+            precision,
+            recall,
+            f1_score,
+            accuracy,
+            ious,
+            hallucination_ratios,
+            missing_prediction_ratios,
+        ) = compute_metrics(
+            data=data,
+            label_metadata=label_metadata,
+            n_pixels=n_pixels,
+        )
+
+        metrics = defaultdict(list)
+
+        metrics[MetricType.Accuracy] = [
+            Accuracy(
+                value=accuracy,
+            )
+        ]
+
+        metrics[MetricType.ConfusionMatrix] = [
+            ConfusionMatrix(
+                confusion_matrix={
+                    self.index_to_label[gt_label_idx]: {
+                        self.index_to_label[pd_label_idx]: {
+                            "iou": float(ious[gt_label_idx, pd_label_idx])
+                        }
+                        for pd_label_idx in range(self.n_labels)
+                        if label_metadata[pd_label_idx, 0] > 0
+                    }
+                    for gt_label_idx in range(self.n_labels)
+                    if label_metadata[gt_label_idx, 0] > 0
+                },
+                hallucinations={
+                    self.index_to_label[pd_label_idx]: {
+                        "percent": float(hallucination_ratios[pd_label_idx])
+                    }
+                    for pd_label_idx in range(self.n_labels)
+                    if label_metadata[pd_label_idx, 0] > 0
+                },
+                missing_predictions={
+                    self.index_to_label[gt_label_idx]: {
+                        "percent": float(
+                            missing_prediction_ratios[gt_label_idx]
+                        )
+                    }
+                    for gt_label_idx in range(self.n_labels)
+                    if label_metadata[gt_label_idx, 0] > 0
+                },
+            )
+        ]
+
+        metrics[MetricType.mIoU] = [
+            mIoU(
+                value=float(ious.diagonal().mean()),
+            )
+        ]
+
+        for label_idx, label in self.index_to_label.items():
+
+            kwargs = {
+                "label": label,
+            }
+
+            # if no groundtruths exists for a label, skip it.
+            if label_metadata[label_idx, 0] == 0:
+                continue
+
+            metrics[MetricType.Precision].append(
+                Precision(
+                    value=float(precision[label_idx]),
+                    **kwargs,
+                )
+            )
+            metrics[MetricType.Recall].append(
+                Recall(
+                    value=float(recall[label_idx]),
+                    **kwargs,
+                )
+            )
+            metrics[MetricType.F1].append(
+                F1(
+                    value=float(f1_score[label_idx]),
+                    **kwargs,
+                )
+            )
+            metrics[MetricType.IoU].append(
+                IoU(
+                    value=float(ious[label_idx, label_idx]),
+                    **kwargs,
+                )
+            )
+
+        for metric in set(metrics.keys()):
+            if metric not in metrics_to_return:
+                del metrics[metric]
+
+        if as_dict:
+            return {
+                mtype: [metric.to_dict() for metric in mvalues]
+                for mtype, mvalues in metrics.items()
+            }
+
+        return metrics
+
+
+class DataLoader:
+    """
+    Segmentation DataLoader.
+    """
+
+    def __init__(self):
+        self._evaluator = Evaluator()
+        self.groundtruth_count = defaultdict(lambda: defaultdict(int))
+        self.prediction_count = defaultdict(lambda: defaultdict(int))
+        self.matrices = list()
+        self.pixel_count = list()
+
+    def _add_datum(self, uid: str) -> int:
+        """
+        Helper function for adding a datum to the cache.
+
+        Parameters
+        ----------
+        uid : str
+            The datum uid.
+
+        Returns
+        -------
+        int
+            The datum index.
+        """
+        if uid in self._evaluator.uid_to_index:
+            raise ValueError(f"Datum with uid `{uid}` has already been added.")
+        index = len(self._evaluator.uid_to_index)
+        self._evaluator.uid_to_index[uid] = index
+        self._evaluator.index_to_uid[index] = uid
+        return index
+
+    def _add_label(self, label: str) -> int:
+        """
+        Helper function for adding a label to the cache.
+
+        Parameters
+        ----------
+        label : str
+            A string label.
+
+        Returns
+        -------
+        int
+            The label's index.
+        """
+        if label not in self._evaluator.label_to_index:
+            label_id = len(self._evaluator.index_to_label)
+            self._evaluator.label_to_index[label] = label_id
+            self._evaluator.index_to_label[label_id] = label
+        return self._evaluator.label_to_index[label]
+
+    def add_data(
+        self,
+        segmentations: list[Segmentation],
+        show_progress: bool = False,
+    ):
+        """
+        Adds segmentations to the cache.
+
+        Parameters
+        ----------
+        segmentations : list[Segmentation]
+            A list of Segmentation objects.
+        show_progress : bool, default=False
+            Toggle for tqdm progress bar.
+        """
+
+        disable_tqdm = not show_progress
+        for segmentation in tqdm(segmentations, disable=disable_tqdm):
+
+            # update metadata
+            self._evaluator.n_datums += 1
+            self._evaluator.n_groundtruths += len(segmentation.groundtruths)
+            self._evaluator.n_predictions += len(segmentation.predictions)
+            self._evaluator.n_pixels += segmentation.size
+            self._evaluator.n_groundtruth_pixels += segmentation.size * len(
+                segmentation.groundtruths
+            )
+            self._evaluator.n_prediction_pixels += segmentation.size * len(
+                segmentation.predictions
+            )
+
+            # update datum cache
+            uid_index = self._add_datum(segmentation.uid)
+
+            groundtruth_labels = np.full(
+                len(segmentation.groundtruths), fill_value=-1
+            )
+            for idx, groundtruth in enumerate(segmentation.groundtruths):
+                label_idx = self._add_label(groundtruth.label)
+                groundtruth_labels[idx] = label_idx
+                self.groundtruth_count[label_idx][
+                    uid_index
+                ] += groundtruth.mask.sum()
+
+            prediction_labels = np.full(
+                len(segmentation.predictions), fill_value=-1
+            )
+            for idx, prediction in enumerate(segmentation.predictions):
+                label_idx = self._add_label(prediction.label)
+                prediction_labels[idx] = label_idx
+                self.prediction_count[label_idx][
+                    uid_index
+                ] += prediction.mask.sum()
+
+            combined_groundtruths = np.stack(
+                [
+                    groundtruth.mask.flatten()
+                    for groundtruth in segmentation.groundtruths
+                ],
+                axis=0,
+            )
+            combined_predictions = np.stack(
+                [
+                    prediction.mask.flatten()
+                    for prediction in segmentation.predictions
+                ],
+                axis=0,
+            )
+
+            self.matrices.append(
+                compute_intermediate_confusion_matrices(
+                    groundtruths=combined_groundtruths,
+                    predictions=combined_predictions,
+                    groundtruth_labels=groundtruth_labels,
+                    prediction_labels=prediction_labels,
+                    n_labels=len(self._evaluator.index_to_label),
+                )
+            )
+            self.pixel_count.append(segmentation.size)
+
+    def finalize(self) -> Evaluator:
+        """
+        Performs data finalization and some preprocessing steps.
+
+        Returns
+        -------
+        Evaluator
+            A ready-to-use evaluator object.
+        """
+
+        if len(self.matrices) == 0:
+            raise ValueError("No data available to create evaluator.")
+
+        n_datums = self._evaluator.n_datums
+        n_labels = len(self._evaluator.index_to_label)
+
+        self._evaluator.n_labels = n_labels
+
+        self._evaluator._label_metadata_per_datum = np.zeros(
+            (2, n_datums, n_labels), dtype=np.int32
+        )
+        for datum_idx in range(n_datums):
+            for label_idx in range(n_labels):
+                gt_count = (
+                    self.groundtruth_count[label_idx].get(datum_idx, 0)
+                    if label_idx in self.groundtruth_count
+                    else 0
+                )
+                pd_count = (
+                    self.prediction_count[label_idx].get(datum_idx, 0)
+                    if label_idx in self.prediction_count
+                    else 0
+                )
+                self._evaluator._label_metadata_per_datum[
+                    :, datum_idx, label_idx
+                ] = np.array([gt_count, pd_count])
+
+        self._evaluator._label_metadata = np.array(
+            [
+                [
+                    np.sum(
+                        self._evaluator._label_metadata_per_datum[
+                            0, :, label_idx
+                        ]
+                    ),
+                    np.sum(
+                        self._evaluator._label_metadata_per_datum[
+                            1, :, label_idx
+                        ]
+                    ),
+                ]
+                for label_idx in range(n_labels)
+            ],
+            dtype=np.int32,
+        )
+
+        self._evaluator._n_pixels_per_datum = np.array(
+            self.pixel_count, dtype=np.int32
+        )
+
+        self._evaluator._confusion_matrices = np.zeros(
+            (n_datums, n_labels + 1, n_labels + 1), dtype=np.int32
+        )
+        for idx, matrix in enumerate(self.matrices):
+            h, w = matrix.shape
+            self._evaluator._confusion_matrices[idx, :h, :w] = matrix
+
+        return self._evaluator

valor_lite/segmentation/metric.py

@@ -0,0 +1,119 @@
+from dataclasses import dataclass
+from enum import Enum
+
+from valor_lite.schemas import Metric
+
+
+class MetricType(Enum):
+    Precision = "Precision"
+    Recall = "Recall"
+    Accuracy = "Accuracy"
+    F1 = "F1"
+    IoU = "IoU"
+    mIoU = "mIoU"
+    ConfusionMatrix = "ConfusionMatrix"
+
+    @classmethod
+    def base(cls):
+        return [
+            cls.Precision,
+            cls.Recall,
+            cls.Accuracy,
+            cls.F1,
+            cls.IoU,
+            cls.mIoU,
+            cls.ConfusionMatrix,
+        ]
+
+
+@dataclass
+class _LabelValue:
+    value: float
+    label: str
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.value,
+            parameters={
+                "label": self.label,
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+class Precision(_LabelValue):
+    pass
+
+
+class Recall(_LabelValue):
+    pass
+
+
+class F1(_LabelValue):
+    pass
+
+
+class IoU(_LabelValue):
+    pass
+
+
+@dataclass
+class _Value:
+    value: float
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.value,
+            parameters={},
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()
+
+
+class Accuracy(_Value):
+    pass
+
+
+class mIoU(_Value):
+    pass
+
+
+@dataclass
+class ConfusionMatrix:
+    confusion_matrix: dict[
+        str,  # ground truth label value
+        dict[
+            str,  # prediction label value
+            dict[str, float],  # iou
+        ],
+    ]
+    hallucinations: dict[
+        str,  # prediction label value
+        dict[str, float],  # percentage of pixels
+    ]
+    missing_predictions: dict[
+        str,  # ground truth label value
+        dict[str, float],  # percentage of pixels
+    ]
+
+    @property
+    def metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value={
+                "confusion_matrix": self.confusion_matrix,
+                "hallucinations": self.hallucinations,
+                "missing_predictions": self.missing_predictions,
+            },
+            parameters={},
+        )
+
+    def to_dict(self) -> dict:
+        return self.metric.to_dict()

{valor_lite-0.33.6.dist-info → valor_lite-0.33.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: valor-lite
-Version: 0.33.6
+Version: 0.33.8
 Summary: Compute valor metrics directly in your client.
 License: MIT License
         

valor_lite-0.33.8.dist-info/RECORD

@@ -0,0 +1,22 @@
+valor_lite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valor_lite/schemas.py,sha256=r4cC10w1xYsA785KmGE4ePeOX3wzEs846vT7QAiVg_I,293
+valor_lite/classification/__init__.py,sha256=2wmmziIzUATm7MbmAcPNLXrEX5l4oeD7XBwPd9bWM3Q,506
+valor_lite/classification/annotation.py,sha256=efgwbkOYoujkg9r0CuzMIRfl93DuZV2ldQeW0CBVfeU,478
+valor_lite/classification/computation.py,sha256=qd9K7CcSGmMm_7shfX47_ZIuB-uE2LLiLMZSS_3NJTk,12093
+valor_lite/classification/manager.py,sha256=6YlkqCwuTcAoa40LU0EfXQyZFTwPyRnt5W19qs-T3Xk,24718
+valor_lite/classification/metric.py,sha256=tAxeuTvO5M9gsQWk47hT_Yea6lbfExe16FgkWYmjKGw,3763
+valor_lite/detection/__init__.py,sha256=PiKfemo8FkZRzBhPSjhil8ahGURLy0Vk_iV25CB4UBU,1139
+valor_lite/detection/annotation.py,sha256=kuW8PF4bitPA6cd5Unr5zqgw8nLnvM4BY0jZW14WFAI,4396
+valor_lite/detection/computation.py,sha256=7rOfVlYDadXcJ1_S0FJRF3IPigcsR7guk_0rXeIdAOE,26919
+valor_lite/detection/manager.py,sha256=QzSkiGUYJ4Z6o1QZKPe36Yc74u052h8g36-fUowRlv0,42620
+valor_lite/detection/metric.py,sha256=Wz4xHg0A7E7BFdUPMnrKnz63P6sD7pwHYM1UQ9_dsgY,8872
+valor_lite/segmentation/__init__.py,sha256=IdarTHKUuUMDvMBmInQu12Mm_NMCbql6Hf0nL5b56Ak,424
+valor_lite/segmentation/annotation.py,sha256=8m5ZsRAcDwQVEvn576Ec1DiNwvtxdKQJXpYoToRugfk,1412
+valor_lite/segmentation/computation.py,sha256=iJkEmTNmw9HwQCxSnpJkQsAdVcFriGhhu_WMks6D7tU,5122
+valor_lite/segmentation/manager.py,sha256=zn-l5NyrkaRck8dq5VOKCJFOtylSXsWuiQ_eBV8m8JM,16921
+valor_lite/segmentation/metric.py,sha256=hNn3lB-XJK5YW3itOWvvRMl6hZyWHMlC6smyeVhxeJE,2275
+valor_lite-0.33.8.dist-info/LICENSE,sha256=M0L53VuwfEEqezhHb7NPeYcO_glw7-k4DMLZQ3eRN64,1068
+valor_lite-0.33.8.dist-info/METADATA,sha256=MRi4I1Bu8ojuc9aUSWzkaaH9l5JMRUmenvHdo6bh50o,1865
+valor_lite-0.33.8.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+valor_lite-0.33.8.dist-info/top_level.txt,sha256=9ujykxSwpl2Hu0_R95UQTR_l07k9UUTSdrpiqmq6zc4,11
+valor_lite-0.33.8.dist-info/RECORD,,

valor_lite-0.33.6.dist-info/RECORD

@@ -1,17 +0,0 @@
-valor_lite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valor_lite/schemas.py,sha256=r4cC10w1xYsA785KmGE4ePeOX3wzEs846vT7QAiVg_I,293
-valor_lite/classification/__init__.py,sha256=2wmmziIzUATm7MbmAcPNLXrEX5l4oeD7XBwPd9bWM3Q,506
-valor_lite/classification/annotation.py,sha256=rMDTvPHdAlvJ6_M2kRrnJQnj1oqKe-lxbncWC7Q50RE,345
-valor_lite/classification/computation.py,sha256=pqAPX6zFlaWyYBnve4sdgJLba_m7smeaqZAsEBvi1no,12776
-valor_lite/classification/manager.py,sha256=qAEGBwb6_Kj2Q0-B3NnRiSfJvS_gBSDJYsT6r8X-g_o,27870
-valor_lite/classification/metric.py,sha256=00qmagf-zQXUZ1qJW_UmN1k35aaYK_7GEM292Tc_cBE,4256
-valor_lite/detection/__init__.py,sha256=PiKfemo8FkZRzBhPSjhil8ahGURLy0Vk_iV25CB4UBU,1139
-valor_lite/detection/annotation.py,sha256=BspLc3SjWXj6qYlGGpzDPHEZ8j7CiFzIL5cNlk0WCAM,2732
-valor_lite/detection/computation.py,sha256=HDFfPTFQN2obm-g570KKDf7SP9V-h09OyMtFEJXsoTA,26323
-valor_lite/detection/manager.py,sha256=dHDGNtYRd_u9iCOTrLpqssdHrepi2N3dlx415kaeCM4,52860
-valor_lite/detection/metric.py,sha256=RYKN17nEFRIZIqmotQa6OyNnU0nkjXyfFIclX_5hGpY,9933
-valor_lite-0.33.6.dist-info/LICENSE,sha256=M0L53VuwfEEqezhHb7NPeYcO_glw7-k4DMLZQ3eRN64,1068
-valor_lite-0.33.6.dist-info/METADATA,sha256=pdZDGSu9gKinRjZo9G-qFmYVLwBw8mqVb0gs6IJVmZE,1865
-valor_lite-0.33.6.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-valor_lite-0.33.6.dist-info/top_level.txt,sha256=9ujykxSwpl2Hu0_R95UQTR_l07k9UUTSdrpiqmq6zc4,11
-valor_lite-0.33.6.dist-info/RECORD,,