roboflow-workflows 0.2.4rc2__tar.gz → 0.2.5__tar.gz

{roboflow_workflows-0.2.4rc2/roboflow_workflows.egg-info → roboflow_workflows-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roboflow-workflows
-Version: 0.2.4rc2
+Version: 0.2.5
 Summary: Roboflow Workflows execution engine and block library
 License: LICENSE.core (Apache 2.0) applies to all files in this repository
         except for files in or under any directory that contains a superseding
@@ -17,7 +17,7 @@ Requires-Dist: typing-extensions<=4.15.0,>=4.8.0
 Requires-Dist: networkx<4.0.0,>=3.0.0
 Requires-Dist: packaging~=24.0
 Requires-Dist: numpy<2.4,>=1.26
-Requires-Dist: supervision<0.30.0,>=0.29.0
+Requires-Dist: supervision<0.31.0,>=0.30.6
 Requires-Dist: opencv-python<4.13.0,>=4.8.1.78
 Requires-Dist: pillow<13.0.0,>=12.3.0
 Requires-Dist: shapely<2.1.0,>=2.0.4

{roboflow_workflows-0.2.4rc2 → roboflow_workflows-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "roboflow-workflows"
-version = "0.2.4rc2"
+version = "0.2.5"
 description = "Roboflow Workflows execution engine and block library"
 readme = "README.md"
 license = {file = "LICENSE"}
@@ -11,7 +11,7 @@ dependencies = [
   "networkx>=3.0.0,<4.0.0",
   "packaging~=24.0",
   "numpy>=1.26,<2.4",
-  "supervision>=0.29.0,<0.30.0",
+  "supervision>=0.30.6,<0.31.0",
   "opencv-python>=4.8.1.78,<4.13.0",
   "pillow>=12.3.0,<13.0.0",
   "shapely>=2.0.4,<2.1.0",

{roboflow_workflows-0.2.4rc2 → roboflow_workflows-0.2.5}/roboflow_workflows/configuration.py

@@ -142,6 +142,7 @@ class FontsConfiguration:
 
 @dataclass(frozen=True)
 class ModelsConfiguration:
+    use_inference_models: bool = True
     lmm_enabled: bool = False
     vlm_segmentation_max_polygon_vertices: int = 500
     clip_version_id: str = "ViT-B-16"

{roboflow_workflows-0.2.4rc2 → roboflow_workflows-0.2.5}/roboflow_workflows/core_steps/analytics/_zone_geometry.py

@@ -221,7 +221,7 @@ class LeanPolygonZone:
             self.current_count = 0
             return np.array([], dtype=bool)
 
-        all_anchors = np.ceil(
+        all_anchors = np.rint(
             _stack_anchor_coordinates(xyxy, self.triggering_anchors)
         ).astype(int)
         mask_h, mask_w = self.mask.shape

{roboflow_workflows-0.2.4rc2 → roboflow_workflows-0.2.5}/roboflow_workflows/core_steps/common/deserializers.py

@@ -265,7 +265,10 @@ def deserialize_detections_kind(
             f"detections, but dictionary misses required keys.",
             context="workflow_execution | runtime_input_validation",
         )
-    parsed_detections = sv.Detections.from_inference(detections)
+    raw_predictions = filter_out_invalid_polygons(predictions=detections["predictions"])
+    parsed_detections = sv.Detections.from_inference(
+        {**detections, "predictions": raw_predictions}
+    )
     height, width = detections["image"]["height"], detections["image"]["width"]
     if len(parsed_detections) == 0:
         # Image dimensions describe the input image, not the rows: keep them on
@@ -280,9 +283,6 @@ def deserialize_detections_kind(
         return parsed_detections
     image_metadata = np.array([[height, width]] * len(parsed_detections))
     parsed_detections.data[IMAGE_DIMENSIONS_KEY] = image_metadata
-    raw_predictions = detections["predictions"]
-    if len(parsed_detections) != len(raw_predictions):
-        raw_predictions = filter_out_invalid_polygons(predictions=raw_predictions)
     detection_ids = [
         detection.get(DETECTION_ID_KEY, str(uuid4())) for detection in raw_predictions
     ]

{roboflow_workflows-0.2.4rc2 → roboflow_workflows-0.2.5}/roboflow_workflows/core_steps/common/inference_response_entities.py

@@ -13,7 +13,7 @@ prediction-level classes referenced from `predictions`.
 """
 
 import base64
-from typing import Any, List, Optional, Union
+from typing import Any, List, Literal, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, Field, field_serializer
 from roboflow_workflows.core_steps.common.segmentation_entities import (
@@ -26,13 +26,15 @@ class InferenceResponseImage(BaseModel):
     """Inference response image information.
 
     Attributes:
-        width (int): The original width of the image used in inference.
-        height (int): The original height of the image used in inference.
+        width (int): The width of the represented image coordinate frame.
+        height (int): The height of the represented image coordinate frame.
     """
 
-    width: int = Field(description="The original width of the image used in inference")
+    width: int = Field(
+        description="The width of the represented image coordinate frame"
+    )
     height: int = Field(
-        description="The original height of the image used in inference"
+        description="The height of the represented image coordinate frame"
     )
 
 
@@ -121,6 +123,35 @@ class WithVisualizationResponse(BaseModel):
         return base64.b64encode(visualization).decode("utf-8")
 
 
+class MaskCoordinateMetadata(BaseModel):
+    """Describe the prediction grid and its mapping to the original image.
+
+    Attributes:
+        coordinate_system (str): Coordinate frame shared by boxes, polygons and encoded RLE masks.
+        width (int): Width of the encoded mask grid.
+        height (int): Height of the encoded mask grid.
+        scale_x (float): Multiply mask x coordinates by this to obtain image x.
+        scale_y (float): Multiply mask y coordinates by this to obtain image y.
+    """
+
+    coordinate_system: Literal["mask_grid"] = Field(
+        default="mask_grid",
+        description="All prediction geometry uses this grid, matching response image dimensions.",
+    )
+    width: int = Field(gt=0, description="Mask-grid width in pixels.", examples=[160])
+    height: int = Field(gt=0, description="Mask-grid height in pixels.", examples=[107])
+    scale_x: float = Field(
+        gt=0,
+        description="Original image width divided by output-grid width.",
+        examples=[4.0],
+    )
+    scale_y: float = Field(
+        gt=0,
+        description="Original image height divided by output-grid height.",
+        examples=[4.0],
+    )
+
+
 class InstanceSegmentationInferenceResponse(
     CvInferenceResponse, WithVisualizationResponse
 ):
@@ -136,3 +167,19 @@ class InstanceSegmentationInferenceResponse(
     predictions: List[
         Union[InstanceSegmentationPrediction, InstanceSegmentationRLEPrediction]
     ]
+    image: Union[List[InferenceResponseImage], InferenceResponseImage] = Field(
+        description="Dimensions of the coordinate frame shared by bounding boxes, "
+        "polygon points and RLE masks. With opt-in this is the selected mask grid; "
+        "otherwise it is the original image. Multi-image responses may provide a list.",
+    )
+    original_image: Optional[InferenceResponseImage] = Field(
+        default=None,
+        description="Original image dimensions retained for opted-in responses, "
+        "including when the selected grid has the same dimensions.",
+    )
+    mask_metadata: Optional[MaskCoordinateMetadata] = Field(
+        default=None,
+        description="Present for opted-in responses in either format. All prediction "
+        "geometry uses this grid. Multiply x coordinates and widths by scale_x, "
+        "and y coordinates and heights by scale_y, to map to original_image.",
+    )

{roboflow_workflows-0.2.4rc2 → roboflow_workflows-0.2.5}/roboflow_workflows/core_steps/common/openrouter.py

@@ -57,6 +57,12 @@ from roboflow_workflows.utils.images import encode_image_to_jpeg_bytes, load_ima
 
 logger = get_logger(__name__)
 
+# Upper bound the Roboflow proxy accepts for `max_tokens` (observed live:
+# "Parameter 'max_tokens' must be an integer in [1, 16384]"). Sent when a
+# block leaves `max_tokens` unset, since omitting it makes the proxy apply
+# its own 500-token default.
+PROXY_MAX_TOKENS_CEILING = 16384
+
 # ---------------------------------------------------------------------------
 # Privacy level
 # ---------------------------------------------------------------------------
@@ -274,7 +280,7 @@ class OpenRouterWorkflowBlockBase(WorkflowBlock):
         openrouter_api_key: str,
         model: str,
         prompts: List[List[dict]],
-        max_tokens: int,
+        max_tokens: Optional[int],
         temperature: Optional[float],
         privacy_level: str,
         max_concurrent_requests: Optional[int],
@@ -310,7 +316,7 @@ class OpenRouterWorkflowBlockBase(WorkflowBlock):
         openrouter_api_key: str,
         model: str,
         prompts: List[List[dict]],
-        max_tokens: int,
+        max_tokens: Optional[int],
         temperature: Optional[float],
         privacy_level: str,
         max_concurrent_requests: Optional[int],
@@ -325,7 +331,10 @@ class OpenRouterWorkflowBlockBase(WorkflowBlock):
         on the returned :class:`OpenRouterResult` objects.
 
         ``temperature`` set to ``None`` omits the parameter so the provider
-        default applies. ``reasoning`` is an optional OpenRouter reasoning
+        default applies. ``max_tokens`` set to ``None`` does the same on the
+        direct path; the proxied path sends :data:`PROXY_MAX_TOKENS_CEILING`
+        instead because the proxy requires the field.
+        ``reasoning`` is an optional OpenRouter reasoning
         config object (e.g. ``{"effort": "low"}`` or ``{"enabled": False}``)
         forwarded verbatim; when the target model rejects the config, the
         request is retried once without it.
@@ -469,7 +478,7 @@ def _execute_proxied_openrouter_request(
     openrouter_api_key: str,
     model: str,
     messages: List[dict],
-    max_tokens: int,
+    max_tokens: Optional[int],
     temperature: Optional[float],
     privacy_level: str,
     reasoning: Optional[dict] = None,
@@ -479,7 +488,11 @@ def _execute_proxied_openrouter_request(
         "openrouter_api_key": openrouter_api_key,
         "model": model,
         "messages": messages,
-        "max_tokens": max_tokens,
+        # The proxy requires the field (absent -> its own 500-token default,
+        # which truncates detection JSON) and rejects values above the cap.
+        "max_tokens": (
+            max_tokens if max_tokens is not None else PROXY_MAX_TOKENS_CEILING
+        ),
         "privacy_level": privacy_level,
     }
     if temperature is not None:
@@ -558,7 +571,7 @@ def _execute_direct_openrouter_request(
     api_key: str,
     model: str,
     messages: List[dict],
-    max_tokens: int,
+    max_tokens: Optional[int],
     temperature: Optional[float],
     privacy_level: str,
     reasoning: Optional[dict] = None,
@@ -574,8 +587,9 @@ def _execute_direct_openrouter_request(
     request_kwargs: Dict[str, Any] = {
         "model": model,
         "messages": messages,
-        "max_tokens": max_tokens,
     }
+    if max_tokens is not None:
+        request_kwargs["max_tokens"] = max_tokens
     if temperature is not None:
         request_kwargs["temperature"] = temperature
     try:

roboflow_workflows-0.2.5/roboflow_workflows/core_steps/common/rle_compact.py

@@ -0,0 +1,87 @@
+"""Zero-densification bridge: inference-models full-frame COCO RLE masks
+(``InstancesRLEMasks``) -> supervision ``CompactMask`` (per-crop RLE).
+
+Why this exists
+---------------
+``inference_models.InstanceDetections`` can carry masks as ``InstancesRLEMasks``:
+a list of **full-frame**, **column-major (Fortran-order)** COCO RLE byte strings
+(one per instance), as produced by ``pycocotools``. The visualisation seam used
+to turn those into an ``sv.Detections`` by decoding the whole stack to a dense
+``(N, H, W)`` boolean array (``coco_rle_masks_to_numpy_mask`` ->
+``pycocotools.mask.decode``). That is O(N·H·W) memory and time and is the
+dominant cost when visualising many instances on high-resolution frames.
+
+``supervision.CompactMask`` stores each mask as an RLE of its **bounding-box
+crop** instead of a full ``(H, W)`` array, and its annotators paint directly
+into the crop region — no full-frame allocation. ``CompactMask.from_coco_rle``
+transcodes full-frame COCO RLE to that crop-scoped RLE with run-length
+arithmetic, so no ``(N, H, W)`` array is ever allocated. This module only adapts
+``InstancesRLEMasks`` to its input format.
+
+Parity contract
+---------------
+:func:`compact_mask_from_coco_rle` produces **exactly** what
+``CompactMask.from_dense(coco_rle_masks_to_numpy_mask(rle), xyxy, image_shape)``
+would produce — same box clipping (clip to ``[0, dim-1]``, inclusive max
+coords), same degenerate-box handling (judged on the raw integer box:
+``x2 < x1``, ``y2 < y1``, or a box entirely outside the image -> ``1x1``
+all-False crop) — just without the dense intermediate. The accompanying unit
+test asserts decoded-mask equality against that reference.
+"""
+
+from typing import Sequence, Tuple, Union
+
+import numpy as np
+from supervision.detection.compact_mask import CompactMask
+
+from inference_models.models.base.types import InstancesRLEMasks
+
+
+def compact_mask_from_coco_rle(
+    image_shape: Tuple[int, int],
+    masks_counts: Sequence[Union[bytes, str]],
+    xyxy: np.ndarray,
+) -> CompactMask:
+    """Build a :class:`CompactMask` from full-frame COCO RLE counts, no densify.
+
+    Args:
+        image_shape: ``(H, W)`` of the full image.
+        masks_counts: one COCO compressed-RLE ``counts`` per instance,
+            column-major, full-frame (``InstancesRLEMasks.masks``).
+        xyxy: ``(N, 4)`` boxes ``[x1, y1, x2, y2]`` (supervision inclusive-max
+            convention), used as the crop bounds — identical to
+            ``CompactMask.from_dense``.
+
+    Returns:
+        A :class:`CompactMask` decode-equal to
+        ``CompactMask.from_dense(decode(masks_counts), xyxy, image_shape)``.
+
+    Raises:
+        ValueError: If a ``counts`` entry is malformed or does not cover
+            ``H*W`` pixels, ``xyxy`` is not shaped ``(len(masks_counts), 4)``,
+            or ``image_shape`` is non-positive or exceeds supervision's
+            per-side limit.
+    """
+    img_h, img_w = int(image_shape[0]), int(image_shape[1])
+    rles = [{"size": [img_h, img_w], "counts": counts} for counts in masks_counts]
+
+    compact_mask = CompactMask.from_coco_rle(rles, xyxy, (img_h, img_w))
+
+    return compact_mask
+
+
+def instances_rle_to_compact_mask(
+    masks: InstancesRLEMasks,
+    xyxy: np.ndarray,
+) -> CompactMask:
+    """Adapter: ``InstancesRLEMasks`` -> ``CompactMask`` (zero densification).
+
+    ``xyxy`` must be the full-frame boxes for the same instances, in the
+    supervision inclusive-max convention (the visualisation seam already has
+    them as a host numpy array).
+    """
+    return compact_mask_from_coco_rle(
+        image_shape=masks.image_size,
+        masks_counts=masks.masks,
+        xyxy=xyxy,
+    )

{roboflow_workflows-0.2.4rc2 → roboflow_workflows-0.2.5}/roboflow_workflows/core_steps/common/utils.py

@@ -3,6 +3,7 @@ import math
 import uuid
 from concurrent.futures import ThreadPoolExecutor
 from copy import deepcopy
+from functools import wraps
 from typing import (
     Any,
     Callable,
@@ -23,6 +24,7 @@ from roboflow_workflows.core_steps.common.keypoints import (
     KEYPOINT_PADDING_CLASS_NAME,
     validate_keypoints_padding,
 )
+from roboflow_workflows.errors import RuntimeInputError
 from roboflow_workflows.execution_engine.constants import (
     DETECTION_ID_KEY,
     HEIGHT_KEY,
@@ -68,8 +70,35 @@ from roboflow_workflows.prototypes.models_provider import (
 )
 from supervision.config import CLASS_NAME_DATA_FIELD, ORIENTED_BOX_COORDINATES
 
+from inference_models.errors import ModelInputError
+
 T = TypeVar("T")
 
+# Brittle but necessary: CLIP models signal a text prompt exceeding the context
+# length only via ModelInputError with this message (inference_models
+# clip/preprocessing.py and inference/models/clip/clip_model.py). Other
+# ModelInputErrors are usually server-side bugs and must stay 5xx.
+CLIP_TEXT_TOO_LONG_ERROR_MARKER = "too long for the model context length"
+
+
+def raise_runtime_input_error_on_clip_text_too_long(
+    run_locally: Callable[..., BlockResult],
+) -> Callable[..., BlockResult]:
+    @wraps(run_locally)
+    def wrapper(*args, **kwargs) -> BlockResult:
+        try:
+            return run_locally(*args, **kwargs)
+        except ModelInputError as error:
+            if CLIP_TEXT_TOO_LONG_ERROR_MARKER not in str(error):
+                raise
+            raise RuntimeInputError(
+                public_message=f"Text input of CLIP step is invalid. Details: {error}",
+                context="workflow_execution | step_execution",
+                inner_error=error,
+            ) from error
+
+    return wrapper
+
 
 def load_core_model(
     model_manager: ModelsProvider,
@@ -103,9 +132,35 @@ def attach_prediction_type_info(
 
 
 def filter_out_invalid_polygons(predictions: List[dict]) -> List[dict]:
-    return [
-        d for d in predictions if "points" not in d or len(d.get("points", [])) >= 3
-    ]
+    if not isinstance(predictions, list):
+        return predictions
+
+    valid_predictions = [p for p in predictions if not _is_short_polygon(p)]
+
+    return valid_predictions
+
+
+def _is_short_polygon(prediction: dict) -> bool:
+    # Mirrors supervision: a `points` sequence with < 3 entries is kept as a box-only
+    # detection (which then drops masks of the whole response) unless RLE is valid.
+    if not isinstance(prediction, dict) or _has_valid_rle_payload(prediction):
+        return False
+
+    points = prediction.get("points")
+    is_short_polygon = isinstance(points, (list, tuple)) and len(points) < 3
+
+    return is_short_polygon
+
+
+def _has_valid_rle_payload(prediction: dict) -> bool:
+    # supervision prefers a valid RLE payload over `points`.
+    return any(
+        isinstance(rle_data, dict) and {"size", "counts"}.issubset(rle_data)
+        for rle_data in (
+            prediction.get("rle"),
+            prediction.get(RLE_MASK_KEY_IN_INFERENCE_RESPONSE),
+        )
+    )
 
 
 def _get_or_create_detection_id(prediction: dict) -> object:
@@ -132,10 +187,8 @@ def convert_inference_detections_batch_to_sv_detections(
     batch_of_detections: List[sv.Detections] = []
     for p in predictions:
         width, height = p[image_key][WIDTH_KEY], p[image_key][HEIGHT_KEY]
-        detections = sv.Detections.from_inference(p)
-        raw_predictions = p[predictions_key]
-        if len(detections) != len(raw_predictions):
-            raw_predictions = filter_out_invalid_polygons(predictions=raw_predictions)
+        raw_predictions = filter_out_invalid_polygons(predictions=p[predictions_key])
+        detections = sv.Detections.from_inference({**p, "predictions": raw_predictions})
         parent_ids = [d.get(PARENT_ID_KEY, "") for d in raw_predictions]
         detection_ids = [_get_or_create_detection_id(d) for d in raw_predictions]
         detections[DETECTION_ID_KEY] = np.array(detection_ids)
@@ -629,10 +682,12 @@ def post_process_ocr_result(
     expected_output_keys: Set[str],
 ) -> BlockResult:
     for prediction, image in zip(predictions, images):
-        raw_predictions = prediction.get("predictions", [])
-        prediction["predictions"] = sv.Detections.from_inference(prediction)
-        if len(prediction["predictions"]) != len(raw_predictions):
-            raw_predictions = filter_out_invalid_polygons(predictions=raw_predictions)
+        raw_predictions = filter_out_invalid_polygons(
+            predictions=prediction.get("predictions", [])
+        )
+        prediction["predictions"] = sv.Detections.from_inference(
+            {**prediction, "predictions": raw_predictions}
+        )
         detection_ids = [_get_or_create_detection_id(p) for p in raw_predictions]
         prediction["predictions"]["detection_id"] = detection_ids
         prediction[PREDICTION_TYPE_KEY] = "ocr"

{roboflow_workflows-0.2.4rc2 → roboflow_workflows-0.2.5}/roboflow_workflows/core_steps/common/vlm_decoding/detection_formats.py

@@ -50,6 +50,19 @@ XYXY_0_1000_PROMPT_TEMPLATE = (
     "Only use these labels: {class_list}"
 )
 
+# Same wording as `XYXY_0_1000_PROMPT_TEMPLATE` on a 0-999 grid, the
+# convention Mistral documents for its models.
+XYXY_0_999_PROMPT_TEMPLATE = (
+    "Detect all objects in this image. "
+    "Output a JSON list where each entry contains the 2D bounding box "
+    'in the key "box_2d" and the text label in the key "label". '
+    'The "box_2d" value must be [x_min, y_min, x_max, y_max]: the '
+    "top-left and bottom-right corners as integers between 0 and 999, "
+    "normalized to the image width (x) and height (y). "
+    "Return only the JSON list, with no extra text. "
+    "Only use these labels: {class_list}"
+)
+
 YXYX_0_1000_PROMPT_TEMPLATE = (
     "Detect all objects in this image. "
     "Output a JSON list where each entry contains the 2D bounding box "
@@ -82,6 +95,7 @@ NAMED_0_1000_PROMPT_TEMPLATE = (
 
 # Coordinate scales.
 NORMALIZED_0_1000_SCALE = 1000.0
+NORMALIZED_0_999_SCALE = 999.0
 PERCENT_SCALE = 100.0
 
 # Entry shape vocabulary. Models drift between the prompted keys and their
@@ -196,6 +210,24 @@ def _convert_xyxy_0_1000(
     return [x_min * scale_x, y_min * scale_y, x_max * scale_x, y_max * scale_y]
 
 
+def _convert_xyxy_0_999(
+    entry: dict,
+    image_width: int,
+    image_height: int,
+    upload_width: Optional[int],
+    upload_height: Optional[int],
+) -> Optional[List[float]]:
+    box = _read_box_2d(entry)
+    if box is None:
+        return None
+    x_min, y_min, x_max, y_max = (
+        _clamp(value, NORMALIZED_0_999_SCALE) for value in box
+    )
+    scale_x = image_width / NORMALIZED_0_999_SCALE
+    scale_y = image_height / NORMALIZED_0_999_SCALE
+    return [x_min * scale_x, y_min * scale_y, x_max * scale_x, y_max * scale_y]
+
+
 def _convert_yxyx_0_1000(
     entry: dict,
     image_width: int,
@@ -365,6 +397,13 @@ DETECTION_BOX_FORMATS: Dict[str, DetectionBoxFormat] = {
         converter=_convert_xyxy_0_1000,
         reads_confidence=False,
     ),
+    "xyxy_0_999": DetectionBoxFormat(
+        name="xyxy_0_999",
+        prompt_template=XYXY_0_999_PROMPT_TEMPLATE,
+        requires_upload_dimensions=False,
+        converter=_convert_xyxy_0_999,
+        reads_confidence=False,
+    ),
     "yxyx_0_1000": DetectionBoxFormat(
         name="yxyx_0_1000",
         prompt_template=YXYX_0_1000_PROMPT_TEMPLATE,
@@ -399,6 +438,7 @@ DETECTION_BOX_FORMATS: Dict[str, DetectionBoxFormat] = {
 BoxFormatName = Literal[
     "xyxy_absolute",
     "xyxy_0_1000",
+    "xyxy_0_999",
     "yxyx_0_1000",
     "xyxy_percent",
     "named_0_1000",

{roboflow_workflows-0.2.4rc2 → roboflow_workflows-0.2.5}/roboflow_workflows/core_steps/common/workload_presets.py

@@ -210,8 +210,8 @@ S3_APPEND_BUFFER_RESTRICTION = RuntimeRestriction(
 # Fire-and-forget writes hide delivery / persistence failures and pile up when
 # the destination is slower than the video stream. Shared by the sinks that
 # offer the switch (PostgreSQL, Kafka producer, Microsoft SQL Server, Event
-# Writer, OPC UA Writer), so the note stays neutral about what the destination
-# is.
+# Writer, OPC UA Writer, MQTT Writer), so the note stays neutral about what the
+# destination is.
 FIRE_AND_FORGET_RESTRICTION = RuntimeRestriction(
     code="fire_and_forget_hides_persistence_failures",
     severity=Severity.SOFT,