valor-lite 0.34.2__py3-none-any.whl → 0.35.0__py3-none-any.whl

valor_lite/object_detection/utilities.py

@@ -3,6 +3,7 @@ from collections import defaultdict
 import numpy as np
 from numpy.typing import NDArray
 
+from valor_lite.object_detection.computation import PairClassification
 from valor_lite.object_detection.metric import Metric, MetricType
 
 
@@ -11,38 +12,28 @@ def unpack_precision_recall_into_metric_lists(
         tuple[
             NDArray[np.float64],
             NDArray[np.float64],
-            NDArray[np.float64],
-            float,
         ],
         tuple[
             NDArray[np.float64],
             NDArray[np.float64],
-            NDArray[np.float64],
-            float,
         ],
         NDArray[np.float64],
         NDArray[np.float64],
-        NDArray[np.float64],
     ],
     iou_thresholds: list[float],
     score_thresholds: list[float],
-    index_to_label: dict[int, str],
+    index_to_label: list[str],
     label_metadata: NDArray[np.int32],
 ):
     (
         (
             average_precision,
             mean_average_precision,
-            average_precision_average_over_ious,
-            mean_average_precision_average_over_ious,
         ),
         (
             average_recall,
             mean_average_recall,
-            average_recall_averaged_over_scores,
-            mean_average_recall_averaged_over_scores,
         ),
-        accuracy,
         precision_recall,
         pr_curves,
     ) = results
@@ -56,7 +47,7 @@ def unpack_precision_recall_into_metric_lists(
             label=label,
         )
         for iou_idx, iou_threshold in enumerate(iou_thresholds)
-        for label_idx, label in index_to_label.items()
+        for label_idx, label in enumerate(index_to_label)
         if int(label_metadata[label_idx, 0]) > 0
     ]
 
@@ -68,19 +59,21 @@ def unpack_precision_recall_into_metric_lists(
         for iou_idx, iou_threshold in enumerate(iou_thresholds)
     ]
 
+    # TODO - (c.zaloom) will be removed in the future
     metrics[MetricType.APAveragedOverIOUs] = [
         Metric.average_precision_averaged_over_IOUs(
-            value=float(average_precision_average_over_ious[label_idx]),
+            value=float(average_precision.mean(axis=0)[label_idx]),
             iou_thresholds=iou_thresholds,
             label=label,
         )
-        for label_idx, label in index_to_label.items()
+        for label_idx, label in enumerate(index_to_label)
         if int(label_metadata[label_idx, 0]) > 0
     ]
 
+    # TODO - (c.zaloom) will be removed in the future
     metrics[MetricType.mAPAveragedOverIOUs] = [
         Metric.mean_average_precision_averaged_over_IOUs(
-            value=float(mean_average_precision_average_over_ious),
+            value=float(mean_average_precision.mean()),
             iou_thresholds=iou_thresholds,
         )
     ]
@@ -93,7 +86,7 @@ def unpack_precision_recall_into_metric_lists(
             label=label,
         )
         for score_idx, score_threshold in enumerate(score_thresholds)
-        for label_idx, label in index_to_label.items()
+        for label_idx, label in enumerate(index_to_label)
         if int(label_metadata[label_idx, 0]) > 0
     ]
 
@@ -106,35 +99,27 @@ def unpack_precision_recall_into_metric_lists(
         for score_idx, score_threshold in enumerate(score_thresholds)
     ]
 
+    # TODO - (c.zaloom) will be removed in the future
     metrics[MetricType.ARAveragedOverScores] = [
         Metric.average_recall_averaged_over_scores(
-            value=float(average_recall_averaged_over_scores[label_idx]),
+            value=float(average_recall.mean(axis=0)[label_idx]),
             score_thresholds=score_thresholds,
             iou_thresholds=iou_thresholds,
             label=label,
         )
-        for label_idx, label in index_to_label.items()
+        for label_idx, label in enumerate(index_to_label)
         if int(label_metadata[label_idx, 0]) > 0
     ]
 
+    # TODO - (c.zaloom) will be removed in the future
     metrics[MetricType.mARAveragedOverScores] = [
         Metric.mean_average_recall_averaged_over_scores(
-            value=float(mean_average_recall_averaged_over_scores),
+            value=float(mean_average_recall.mean()),
             score_thresholds=score_thresholds,
             iou_thresholds=iou_thresholds,
         )
     ]
 
-    metrics[MetricType.Accuracy] = [
-        Metric.accuracy(
-            value=float(accuracy[iou_idx, score_idx]),
-            iou_threshold=iou_threshold,
-            score_threshold=score_threshold,
-        )
-        for iou_idx, iou_threshold in enumerate(iou_thresholds)
-        for score_idx, score_threshold in enumerate(score_thresholds)
-    ]
-
     metrics[MetricType.PrecisionRecallCurve] = [
         Metric.precision_recall_curve(
             precisions=pr_curves[iou_idx, label_idx, :, 0].tolist(),  # type: ignore[reportArgumentType]
@@ -143,12 +128,11 @@ def unpack_precision_recall_into_metric_lists(
             label=label,
         )
         for iou_idx, iou_threshold in enumerate(iou_thresholds)
-        for label_idx, label in index_to_label.items()
+        for label_idx, label in enumerate(index_to_label)
         if label_metadata[label_idx, 0] > 0
     ]
 
-    for label_idx, label in index_to_label.items():
-
+    for label_idx, label in enumerate(index_to_label):
         if label_metadata[label_idx, 0] == 0:
             continue
 
@@ -192,315 +176,148 @@ def unpack_precision_recall_into_metric_lists(
     return metrics
 
 
-def _convert_example_to_dict(box: NDArray[np.float16]) -> dict[str, float]:
-    """
-    Converts a cached bounding box example to dictionary format.
-    """
-    return {
-        "xmin": float(box[0]),
-        "xmax": float(box[1]),
-        "ymin": float(box[2]),
-        "ymax": float(box[3]),
-    }
-
-
-def _unpack_confusion_matrix_value(
-    confusion_matrix: NDArray[np.float64],
-    number_of_labels: int,
-    number_of_examples: int,
-    index_to_uid: dict[int, str],
-    index_to_label: dict[int, str],
-    groundtruth_examples: dict[int, NDArray[np.float16]],
-    prediction_examples: dict[int, NDArray[np.float16]],
-) -> dict[
-    str,
-    dict[
-        str,
-        dict[
-            str,
-            int
-            | list[
-                dict[
-                    str,
-                    str | dict[str, float] | float,
-                ]
-            ],
-        ],
-    ],
-]:
-    """
-    Unpacks a numpy array of confusion matrix counts and examples.
-    """
-
-    datum_idx = lambda gt_label_idx, pd_label_idx, example_idx: int(  # noqa: E731 - lambda fn
-        confusion_matrix[
-            gt_label_idx,
-            pd_label_idx,
-            example_idx * 4 + 1,
-        ]
+def _create_empty_confusion_matrix(index_to_labels: list[str]):
+    unmatched_ground_truths = dict()
+    unmatched_predictions = dict()
+    confusion_matrix = dict()
+    for label in index_to_labels:
+        unmatched_ground_truths[label] = {"count": 0, "examples": []}
+        unmatched_predictions[label] = {"count": 0, "examples": []}
+        confusion_matrix[label] = {}
+        for plabel in index_to_labels:
+            confusion_matrix[label][plabel] = {"count": 0, "examples": []}
+    return (
+        confusion_matrix,
+        unmatched_predictions,
+        unmatched_ground_truths,
     )
 
-    groundtruth_idx = lambda gt_label_idx, pd_label_idx, example_idx: int(  # noqa: E731 - lambda fn
-        confusion_matrix[
-            gt_label_idx,
-            pd_label_idx,
-            example_idx * 4 + 2,
-        ]
-    )
 
-    prediction_idx = lambda gt_label_idx, pd_label_idx, example_idx: int(  # noqa: E731 - lambda fn
-        confusion_matrix[
-            gt_label_idx,
-            pd_label_idx,
-            example_idx * 4 + 3,
-        ]
-    )
+def _unpack_confusion_matrix(
+    ids: NDArray[np.int32],
+    mask_matched: NDArray[np.bool_],
+    mask_fp_unmatched: NDArray[np.bool_],
+    mask_fn_unmatched: NDArray[np.bool_],
+    index_to_datum_id: list[str],
+    index_to_groundtruth_id: list[str],
+    index_to_prediction_id: list[str],
+    index_to_label: list[str],
+    iou_threhsold: float,
+    score_threshold: float,
+):
+    (
+        confusion_matrix,
+        unmatched_predictions,
+        unmatched_ground_truths,
+    ) = _create_empty_confusion_matrix(index_to_label)
 
-    score_idx = lambda gt_label_idx, pd_label_idx, example_idx: float(  # noqa: E731 - lambda fn
-        confusion_matrix[
-            gt_label_idx,
-            pd_label_idx,
-            example_idx * 4 + 4,
-        ]
+    unique_matches = np.unique(
+        ids[np.ix_(mask_matched, (0, 1, 2, 3, 4))], axis=0  # type: ignore - numpy ix_ typing
     )
-
-    return {
-        index_to_label[gt_label_idx]: {
-            index_to_label[pd_label_idx]: {
-                "count": max(
-                    int(confusion_matrix[gt_label_idx, pd_label_idx, 0]),
-                    0,
-                ),
-                "examples": [
-                    {
-                        "datum": index_to_uid[
-                            datum_idx(gt_label_idx, pd_label_idx, example_idx)
-                        ],
-                        "groundtruth": _convert_example_to_dict(
-                            groundtruth_examples[
-                                datum_idx(
-                                    gt_label_idx,
-                                    pd_label_idx,
-                                    example_idx,
-                                )
-                            ][
-                                groundtruth_idx(
-                                    gt_label_idx,
-                                    pd_label_idx,
-                                    example_idx,
-                                )
-                            ]
-                        ),
-                        "prediction": _convert_example_to_dict(
-                            prediction_examples[
-                                datum_idx(
-                                    gt_label_idx,
-                                    pd_label_idx,
-                                    example_idx,
-                                )
-                            ][
-                                prediction_idx(
-                                    gt_label_idx,
-                                    pd_label_idx,
-                                    example_idx,
-                                )
-                            ]
-                        ),
-                        "score": score_idx(
-                            gt_label_idx, pd_label_idx, example_idx
-                        ),
-                    }
-                    for example_idx in range(number_of_examples)
-                    if datum_idx(gt_label_idx, pd_label_idx, example_idx) >= 0
-                ],
-            }
-            for pd_label_idx in range(number_of_labels)
-        }
-        for gt_label_idx in range(number_of_labels)
-    }
-
-
-def _unpack_unmatched_predictions_value(
-    unmatched_predictions: NDArray[np.float64],
-    number_of_labels: int,
-    number_of_examples: int,
-    index_to_uid: dict[int, str],
-    index_to_label: dict[int, str],
-    prediction_examples: dict[int, NDArray[np.float16]],
-) -> dict[
-    str,
-    dict[
-        str,
-        int | list[dict[str, str | float | dict[str, float]]],
-    ],
-]:
-    """
-    Unpacks a numpy array of unmatched_prediction counts and examples.
-    """
-
-    datum_idx = (
-        lambda pd_label_idx, example_idx: int(  # noqa: E731 - lambda fn
-            unmatched_predictions[
-                pd_label_idx,
-                example_idx * 3 + 1,
-            ]
-        )
+    unique_unmatched_predictions = np.unique(
+        ids[np.ix_(mask_fp_unmatched, (0, 2, 4))], axis=0  # type: ignore - numpy ix_ typing
     )
-
-    prediction_idx = (
-        lambda pd_label_idx, example_idx: int(  # noqa: E731 - lambda fn
-            unmatched_predictions[
-                pd_label_idx,
-                example_idx * 3 + 2,
-            ]
-        )
+    unique_unmatched_groundtruths = np.unique(
+        ids[np.ix_(mask_fn_unmatched, (0, 1, 3))], axis=0  # type: ignore - numpy ix_ typing
     )
 
-    score_idx = (
-        lambda pd_label_idx, example_idx: float(  # noqa: E731 - lambda fn
-            unmatched_predictions[
-                pd_label_idx,
-                example_idx * 3 + 3,
-            ]
-        )
-    )
+    n_matched = unique_matches.shape[0]
+    n_unmatched_predictions = unique_unmatched_predictions.shape[0]
+    n_unmatched_groundtruths = unique_unmatched_groundtruths.shape[0]
+    n_max = max(n_matched, n_unmatched_groundtruths, n_unmatched_predictions)
 
-    return {
-        index_to_label[pd_label_idx]: {
-            "count": max(
-                int(unmatched_predictions[pd_label_idx, 0]),
-                0,
-            ),
-            "examples": [
+    for idx in range(n_max):
+        if idx < n_unmatched_groundtruths:
+            label = index_to_label[unique_unmatched_groundtruths[idx, 2]]
+            unmatched_ground_truths[label]["count"] += 1
+            unmatched_ground_truths[label]["examples"].append(
                 {
-                    "datum": index_to_uid[
-                        datum_idx(pd_label_idx, example_idx)
+                    "datum_id": index_to_datum_id[
+                        unique_unmatched_groundtruths[idx, 0]
+                    ],
+                    "ground_truth_id": index_to_groundtruth_id[
+                        unique_unmatched_groundtruths[idx, 1]
                     ],
-                    "prediction": _convert_example_to_dict(
-                        prediction_examples[
-                            datum_idx(pd_label_idx, example_idx)
-                        ][prediction_idx(pd_label_idx, example_idx)]
-                    ),
-                    "score": score_idx(pd_label_idx, example_idx),
                 }
-                for example_idx in range(number_of_examples)
-                if datum_idx(pd_label_idx, example_idx) >= 0
-            ],
-        }
-        for pd_label_idx in range(number_of_labels)
-    }
-
-
-def _unpack_unmatched_ground_truths_value(
-    unmatched_ground_truths: NDArray[np.int32],
-    number_of_labels: int,
-    number_of_examples: int,
-    index_to_uid: dict[int, str],
-    index_to_label: dict[int, str],
-    groundtruth_examples: dict[int, NDArray[np.float16]],
-) -> dict[str, dict[str, int | list[dict[str, str | dict[str, float]]]]]:
-    """
-    Unpacks a numpy array of unmatched ground truth counts and examples.
-    """
-
-    datum_idx = (
-        lambda gt_label_idx, example_idx: int(  # noqa: E731 - lambda fn
-            unmatched_ground_truths[
-                gt_label_idx,
-                example_idx * 2 + 1,
-            ]
-        )
-    )
-
-    groundtruth_idx = (
-        lambda gt_label_idx, example_idx: int(  # noqa: E731 - lambda fn
-            unmatched_ground_truths[
-                gt_label_idx,
-                example_idx * 2 + 2,
-            ]
-        )
-    )
-
-    return {
-        index_to_label[gt_label_idx]: {
-            "count": max(
-                int(unmatched_ground_truths[gt_label_idx, 0]),
-                0,
-            ),
-            "examples": [
+            )
+        if idx < n_unmatched_predictions:
+            label = index_to_label[unique_unmatched_predictions[idx, 2]]
+            unmatched_predictions[label]["count"] += 1
+            unmatched_predictions[label]["examples"].append(
                 {
-                    "datum": index_to_uid[
-                        datum_idx(gt_label_idx, example_idx)
+                    "datum_id": index_to_datum_id[
+                        unique_unmatched_predictions[idx, 0]
+                    ],
+                    "prediction_id": index_to_prediction_id[
+                        unique_unmatched_predictions[idx, 1]
                     ],
-                    "groundtruth": _convert_example_to_dict(
-                        groundtruth_examples[
-                            datum_idx(gt_label_idx, example_idx)
-                        ][groundtruth_idx(gt_label_idx, example_idx)]
-                    ),
                 }
-                for example_idx in range(number_of_examples)
-                if datum_idx(gt_label_idx, example_idx) >= 0
-            ],
-        }
-        for gt_label_idx in range(number_of_labels)
-    }
+            )
+        if idx < n_matched:
+            glabel = index_to_label[unique_matches[idx, 3]]
+            plabel = index_to_label[unique_matches[idx, 4]]
+            confusion_matrix[glabel][plabel]["count"] += 1
+            confusion_matrix[glabel][plabel]["examples"].append(
+                {
+                    "datum_id": index_to_datum_id[unique_matches[idx, 0]],
+                    "ground_truth_id": index_to_groundtruth_id[
+                        unique_matches[idx, 1]
+                    ],
+                    "prediction_id": index_to_prediction_id[
+                        unique_matches[idx, 2]
+                    ],
+                }
+            )
+
+    return Metric.confusion_matrix(
+        confusion_matrix=confusion_matrix,
+        unmatched_ground_truths=unmatched_ground_truths,
+        unmatched_predictions=unmatched_predictions,
+        iou_threshold=iou_threhsold,
+        score_threshold=score_threshold,
+    )
 
 
 def unpack_confusion_matrix_into_metric_list(
-    results: tuple[
-        NDArray[np.float64],
-        NDArray[np.float64],
-        NDArray[np.int32],
-    ],
+    results: NDArray[np.uint8],
+    detailed_pairs: NDArray[np.float64],
     iou_thresholds: list[float],
     score_thresholds: list[float],
-    number_of_examples: int,
-    index_to_label: dict[int, str],
-    index_to_uid: dict[int, str],
-    groundtruth_examples: dict[int, NDArray[np.float16]],
-    prediction_examples: dict[int, NDArray[np.float16]],
+    index_to_datum_id: list[str],
+    index_to_groundtruth_id: list[str],
+    index_to_prediction_id: list[str],
+    index_to_label: list[str],
 ) -> list[Metric]:
-    (
-        confusion_matrix,
-        unmatched_predictions,
-        unmatched_ground_truths,
-    ) = results
-    n_labels = len(index_to_label)
+
+    ids = detailed_pairs[:, :5].astype(np.int32)
+
+    mask_matched = (
+        np.bitwise_and(
+            results, PairClassification.TP | PairClassification.FP_FN_MISCLF
+        )
+        > 0
+    )
+    mask_fp_unmatched = (
+        np.bitwise_and(results, PairClassification.FP_UNMATCHED) > 0
+    )
+    mask_fn_unmatched = (
+        np.bitwise_and(results, PairClassification.FN_UNMATCHED) > 0
+    )
+
     return [
-        Metric.confusion_matrix(
-            iou_threshold=iou_threshold,
+        _unpack_confusion_matrix(
+            ids=ids,
+            mask_matched=mask_matched[iou_idx, score_idx],
+            mask_fp_unmatched=mask_fp_unmatched[iou_idx, score_idx],
+            mask_fn_unmatched=mask_fn_unmatched[iou_idx, score_idx],
+            index_to_datum_id=index_to_datum_id,
+            index_to_groundtruth_id=index_to_groundtruth_id,
+            index_to_prediction_id=index_to_prediction_id,
+            index_to_label=index_to_label,
+            iou_threhsold=iou_threshold,
             score_threshold=score_threshold,
-            maximum_number_of_examples=number_of_examples,
-            confusion_matrix=_unpack_confusion_matrix_value(
-                confusion_matrix=confusion_matrix[iou_idx, score_idx, :, :, :],
-                number_of_labels=n_labels,
-                number_of_examples=number_of_examples,
-                index_to_label=index_to_label,
-                index_to_uid=index_to_uid,
-                groundtruth_examples=groundtruth_examples,
-                prediction_examples=prediction_examples,
-            ),
-            unmatched_predictions=_unpack_unmatched_predictions_value(
-                unmatched_predictions=unmatched_predictions[
-                    iou_idx, score_idx, :, :
-                ],
-                number_of_labels=n_labels,
-                number_of_examples=number_of_examples,
-                index_to_label=index_to_label,
-                index_to_uid=index_to_uid,
-                prediction_examples=prediction_examples,
-            ),
-            unmatched_ground_truths=_unpack_unmatched_ground_truths_value(
-                unmatched_ground_truths=unmatched_ground_truths[
-                    iou_idx, score_idx, :, :
-                ],
-                number_of_labels=n_labels,
-                number_of_examples=number_of_examples,
-                index_to_label=index_to_label,
-                index_to_uid=index_to_uid,
-                groundtruth_examples=groundtruth_examples,
-            ),
         )
         for iou_idx, iou_threshold in enumerate(iou_thresholds)
         for score_idx, score_threshold in enumerate(score_thresholds)
+        if (results[iou_idx, score_idx] != -1).any()
     ]

{valor_lite-0.34.2.dist-info → valor_lite-0.35.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valor-lite
-Version: 0.34.2
+Version: 0.35.0
 Summary: Evaluate machine learning models.
 Project-URL: homepage, https://www.striveworks.com
 Requires-Python: >=3.10

{valor_lite-0.34.2.dist-info → valor_lite-0.35.0.dist-info}/RECORD

@@ -9,12 +9,12 @@ valor_lite/classification/manager.py,sha256=cZ6-DKao59QqF0JF_U26tBoydpCElAAH8rRy
 valor_lite/classification/metric.py,sha256=_mW3zynmpW8jUIhK2OeX4usdftHgHM9_l7EAbEe2N3w,12288
 valor_lite/classification/numpy_compatibility.py,sha256=roqtTetsm1_HxuaejrthQdydjsRIy-FpXpGb86cLh_E,365
 valor_lite/classification/utilities.py,sha256=eG-Qhd213uf2GXuuqsPxCgBRBFV-z_ADbzneF1kE368,6964
-valor_lite/object_detection/__init__.py,sha256=Ql8rju2q7y0Zd9zFvtBJDRhgQFDm1RSYkTsyH3ZE6pA,648
-valor_lite/object_detection/annotation.py,sha256=x9bsl8b75yvkMByXXiIYI9d9T03olDqtykSvKJc3aFw,7729
-valor_lite/object_detection/computation.py,sha256=zfVTl_TDK3rho3282VcruTvBK6DqbxduP7tE7esMFUY,28345
-valor_lite/object_detection/manager.py,sha256=uo9o0gWBQUkTTgwTluhXk0ouVDW8qiyrqTwJD6PJDKE,23043
-valor_lite/object_detection/metric.py,sha256=npK2sxiwCUTKlRlFym1AlZTvP9herf9lakbsBDwljGM,24901
-valor_lite/object_detection/utilities.py,sha256=42RRyP6L3eWtDY_f7qs7f0WTjhcibmUBu2I4yAwupF0,16456
+valor_lite/object_detection/__init__.py,sha256=fk1f1i-r7cu-2JioP89XJt3ZNlpH02V5g5jgxFg3_W4,295
+valor_lite/object_detection/annotation.py,sha256=LVec-rIk408LuFxcOoIkPk0QZMWSSxbmsady4wapC1s,7007
+valor_lite/object_detection/computation.py,sha256=P4GD-Ho1n4dUiiUMLVCiDvIDJoeE3e3U1ZPzXUG4GE4,22335
+valor_lite/object_detection/manager.py,sha256=1jGbSoaf5XCvUz716CWnmx8YIF6WJCAiFOW1UUksSz0,28172
+valor_lite/object_detection/metric.py,sha256=sUYSZwXYfIyfmXG6_7Tje1_ZL_QwvecPq85jrGmwOWE,22739
+valor_lite/object_detection/utilities.py,sha256=tNdv5dL7JhzOamGQkZ8x3ocZoTwPI6K8rcRAGMhp2nc,11217
 valor_lite/semantic_segmentation/__init__.py,sha256=BhTUbwbdJa1FdS4ZA3QSIZ8TuJmdGGLGCd5hX6SzKa4,297
 valor_lite/semantic_segmentation/annotation.py,sha256=xd2qJyIeTW8CT_Goyu3Kvl_51b9b6D3WvUfqwShR0Sk,4990
 valor_lite/semantic_segmentation/benchmark.py,sha256=iVdxUo9LgDbbXUa6eRhZ49LOYw-yyr2W4p9FP3KHg0k,3848
@@ -34,7 +34,7 @@ valor_lite/text_generation/llm/instructions.py,sha256=fz2onBZZWcl5W8iy7zEWkPGU9N
 valor_lite/text_generation/llm/integrations.py,sha256=-rTfdAjq1zH-4ixwYuMQEOQ80pIFzMTe0BYfroVx3Pg,6974
 valor_lite/text_generation/llm/utilities.py,sha256=bjqatGgtVTcl1PrMwiDKTYPGJXKrBrx7PDtzIblGSys,1178
 valor_lite/text_generation/llm/validators.py,sha256=Wzr5RlfF58_2wOU-uTw7C8skan_fYdhy4Gfn0jSJ8HM,2700
-valor_lite-0.34.2.dist-info/METADATA,sha256=hHwCwG9A_jQzo4tTo_LABVpK3eaFvWExPqEgpT1nQLQ,5062
-valor_lite-0.34.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-valor_lite-0.34.2.dist-info/top_level.txt,sha256=9ujykxSwpl2Hu0_R95UQTR_l07k9UUTSdrpiqmq6zc4,11
-valor_lite-0.34.2.dist-info/RECORD,,
+valor_lite-0.35.0.dist-info/METADATA,sha256=MjRfyaj-XYIoJrzF7GhHKUy0tiWY6L5hzWvzu3uC-3U,5062
+valor_lite-0.35.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+valor_lite-0.35.0.dist-info/top_level.txt,sha256=9ujykxSwpl2Hu0_R95UQTR_l07k9UUTSdrpiqmq6zc4,11
+valor_lite-0.35.0.dist-info/RECORD,,

{valor_lite-0.34.2.dist-info → valor_lite-0.35.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any