rasa-pro 3.11.0rc3__py3-none-any.whl → 3.11.1__py3-none-any.whl

rasa/__main__.py

@@ -1,4 +1,5 @@
 import argparse
+from typing import Optional, List
 import structlog
 import os
 import platform
@@ -97,12 +98,17 @@ def print_version() -> None:
     print(f"License Expires   :         {get_license_expiration_date()}")
 
 
-def main() -> None:
-    """Run as standalone python application."""
+def main(raw_arguments: Optional[List[str]] = None) -> None:
+    """Run as standalone python application.
+
+    Args:
+        raw_arguments: Arguments to parse. If not provided,
+            arguments will be taken from the command line.
+    """
     warn_if_rasa_plus_package_installed()
     parse_last_positional_argument_as_model_path()
     arg_parser = create_argument_parser()
-    cmdline_arguments = arg_parser.parse_args()
+    cmdline_arguments = arg_parser.parse_args(raw_arguments)
 
     log_level = getattr(cmdline_arguments, "loglevel", None)
     logging_config_file = getattr(cmdline_arguments, "logging_config_file", None)

rasa/cli/studio/upload.py

@@ -32,25 +32,10 @@ def add_subparser(
     set_upload_arguments(upload_parser)
 
 
-def add_flows_param(
-    parser: argparse.ArgumentParser,
-    help_text: str = "Name of flows file to upload to Rasa Studio. Works with --calm",
-    default_path: str = "flows.yml",
-) -> None:
-    parser.add_argument(
-        "--flows",
-        default=default_path,
-        nargs="+",
-        type=str,
-        help=help_text,
-    )
-
-
 def set_upload_arguments(parser: argparse.ArgumentParser) -> None:
     """Add arguments for running `rasa upload`."""
     add_data_param(parser, data_type="training")
     add_domain_param(parser)
-    add_flows_param(parser)
     add_config_param(parser)
     add_endpoint_param(parser, help_text="Path to the endpoints file.")
 

rasa/cli/utils.py

@@ -305,7 +305,7 @@ def _validate_domain(validator: "Validator") -> bool:
     valid_forms_in_stories_rules = validator.verify_forms_in_stories_rules()
     valid_form_slots = validator.verify_form_slots()
     valid_slot_mappings = validator.verify_slot_mappings()
-    valid_responses = validator.check_for_no_empty_paranthesis_in_responses()
+    valid_responses = validator.check_for_no_empty_parenthesis_in_responses()
     valid_buttons = validator.validate_button_payloads()
     return (
         valid_domain_validity

rasa/core/channels/development_inspector.py

@@ -128,9 +128,12 @@ class DevelopmentInspectProxy(InputChannel):
 
             inspect_path = app.url_for(f"{app.name}.{underlying_webhook.name}.inspect")
 
+            # replace 0.0.0.0 with localhost
+            serve_location = app.serve_location.replace("0.0.0.0", "localhost")
+
             print_info(
                 f"Development inspector for channel {self.name()} is running. To "
-                f"inspect conversations, visit {app.serve_location}{inspect_path}"
+                f"inspect conversations, visit {serve_location}{inspect_path}"
             )
 
         underlying_webhook.add_websocket_route(

rasa/core/channels/voice_stream/asr/asr_engine.py

@@ -1,5 +1,14 @@
 from dataclasses import dataclass
-from typing import Dict, AsyncIterator, Any, Generic, Optional, Type, TypeVar
+from typing import (
+    Dict,
+    AsyncIterator,
+    Any,
+    Generic,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+)
 
 from websockets.legacy.client import WebSocketClientProtocol
 
@@ -7,6 +16,7 @@ from rasa.core.channels.voice_stream.asr.asr_event import ASREvent
 from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.util import MergeableConfig
 from rasa.shared.exceptions import ConnectionException
+from rasa.shared.utils.common import validate_environment
 
 T = TypeVar("T", bound="ASREngineConfig")
 E = TypeVar("E", bound="ASREngine")
@@ -18,9 +28,17 @@ class ASREngineConfig(MergeableConfig):
 
 
 class ASREngine(Generic[T]):
+    required_env_vars: Tuple[str, ...] = ()
+    required_packages: Tuple[str, ...] = ()
+
     def __init__(self, config: Optional[T] = None):
         self.config = self.get_default_config().merge(config)
         self.asr_socket: Optional[WebSocketClientProtocol] = None
+        validate_environment(
+            self.required_env_vars,
+            self.required_packages,
+            f"ASR Engine {self.__class__.__name__}",
+        )
 
     async def connect(self) -> None:
         self.asr_socket = await self.open_websocket_connection()

rasa/core/channels/voice_stream/asr/azure.py

@@ -10,6 +10,7 @@ from rasa.core.channels.voice_stream.asr.asr_event import (
     UserIsSpeaking,
 )
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
+from rasa.shared.constants import AZURE_SPEECH_API_KEY_ENV_VAR
 from rasa.shared.exceptions import ConnectionException
 
 
@@ -20,10 +21,14 @@ class AzureASRConfig(ASREngineConfig):
 
 
 class AzureASR(ASREngine[AzureASRConfig]):
+    required_env_vars = (AZURE_SPEECH_API_KEY_ENV_VAR,)
+    required_packages = ("azure.cognitiveservices.speech",)
+
     def __init__(self, config: Optional[AzureASRConfig] = None):
+        super().__init__(config)
+
         import azure.cognitiveservices.speech as speechsdk
 
-        super().__init__(config)
         self.speech_recognizer: Optional[speechsdk.SpeechRecognizer] = None
         self.stream: Optional[speechsdk.audio.PushAudioInputStream] = None
         self.is_recognizing = False
@@ -31,6 +36,10 @@ class AzureASR(ASREngine[AzureASRConfig]):
             asyncio.Queue()
         )
 
+    @staticmethod
+    def validate_environment() -> None:
+        """Make sure all needed requirements for this component are met."""
+
     def signal_user_is_speaking(self, event: Any) -> None:
         """Replace the azure event with a generic is speaking event."""
         self.fill_queue(UserIsSpeaking())
@@ -43,7 +52,7 @@ class AzureASR(ASREngine[AzureASRConfig]):
         import azure.cognitiveservices.speech as speechsdk
 
         speech_config = speechsdk.SpeechConfig(
-            subscription=os.environ["AZURE_SPEECH_API_KEY"],
+            subscription=os.environ[AZURE_SPEECH_API_KEY_ENV_VAR],
             region=self.config.speech_region,
         )
         audio_format = speechsdk.audio.AudioStreamFormat(

rasa/core/channels/voice_stream/asr/deepgram.py

@@ -13,8 +13,7 @@ from rasa.core.channels.voice_stream.asr.asr_event import (
     UserIsSpeaking,
 )
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
-
-DEEPGRAM_API_KEY = "DEEPGRAM_API_KEY"
+from rasa.shared.constants import DEEPGRAM_API_KEY_ENV_VAR
 
 
 @dataclass
@@ -28,13 +27,15 @@ class DeepgramASRConfig(ASREngineConfig):
 
 
 class DeepgramASR(ASREngine[DeepgramASRConfig]):
+    required_env_vars = (DEEPGRAM_API_KEY_ENV_VAR,)
+
     def __init__(self, config: Optional[DeepgramASRConfig] = None):
         super().__init__(config)
         self.accumulated_transcript = ""
 
     async def open_websocket_connection(self) -> WebSocketClientProtocol:
         """Connect to the ASR system."""
-        deepgram_api_key = os.environ[DEEPGRAM_API_KEY]
+        deepgram_api_key = os.environ[DEEPGRAM_API_KEY_ENV_VAR]
         extra_headers = {"Authorization": f"Token {deepgram_api_key}"}
         api_url = self._get_api_url()
         query_params = self._get_query_params()

rasa/core/channels/voice_stream/tts/azure.py

@@ -12,6 +12,7 @@ from rasa.core.channels.voice_stream.tts.tts_engine import (
     TTSEngineConfig,
     TTSError,
 )
+from rasa.shared.constants import AZURE_SPEECH_API_KEY_ENV_VAR
 from rasa.shared.exceptions import ConnectionException
 
 
@@ -25,6 +26,7 @@ class AzureTTSConfig(TTSEngineConfig):
 
 class AzureTTS(TTSEngine[AzureTTSConfig]):
     session: Optional[aiohttp.ClientSession] = None
+    required_env_vars = (AZURE_SPEECH_API_KEY_ENV_VAR,)
 
     def __init__(self, config: Optional[AzureTTSConfig] = None):
         super().__init__(config)
@@ -66,7 +68,7 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
 
     @staticmethod
     def get_request_headers() -> dict[str, str]:
-        azure_speech_api_key = os.environ["AZURE_SPEECH_API_KEY"]
+        azure_speech_api_key = os.environ[AZURE_SPEECH_API_KEY_ENV_VAR]
         return {
             "Ocp-Apim-Subscription-Key": azure_speech_api_key,
             "Content-Type": "application/ssml+xml",

rasa/core/channels/voice_stream/tts/cartesia.py

@@ -11,12 +11,11 @@ from rasa.core.channels.voice_stream.tts.tts_engine import (
 
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
+from rasa.shared.constants import CARTESIA_API_KEY_ENV_VAR
 from rasa.shared.exceptions import ConnectionException
 
 structlogger = structlog.get_logger()
 
-CARTESIA_API_KEY = "CARTESIA_API_KEY"
-
 
 @dataclass
 class CartesiaTTSConfig(TTSEngineConfig):
@@ -26,6 +25,7 @@ class CartesiaTTSConfig(TTSEngineConfig):
 
 class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
     session: Optional[aiohttp.ClientSession] = None
+    required_env_vars = (CARTESIA_API_KEY_ENV_VAR,)
 
     def __init__(self, config: Optional[CartesiaTTSConfig] = None):
         super().__init__(config)
@@ -62,7 +62,7 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
 
     @staticmethod
     def get_request_headers(config: CartesiaTTSConfig) -> dict[str, str]:
-        cartesia_api_key = os.environ[CARTESIA_API_KEY]
+        cartesia_api_key = os.environ[CARTESIA_API_KEY_ENV_VAR]
         return {
             "Cartesia-Version": str(config.version),
             "Content-Type": "application/json",

rasa/core/channels/voice_stream/tts/tts_engine.py

@@ -1,9 +1,10 @@
-from typing import AsyncIterator, Dict, Generic, Optional, Type, TypeVar
+from typing import AsyncIterator, Dict, Generic, Optional, Tuple, Type, TypeVar
 from dataclasses import dataclass
 
 from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.util import MergeableConfig
 from rasa.shared.exceptions import RasaException
+from rasa.shared.utils.common import validate_environment
 
 
 class TTSError(RasaException):
@@ -22,8 +23,16 @@ class TTSEngineConfig(MergeableConfig):
 
 
 class TTSEngine(Generic[T]):
+    required_env_vars: Tuple[str, ...] = ()
+    required_packages: Tuple[str, ...] = ()
+
     def __init__(self, config: Optional[T] = None):
         self.config = self.get_default_config().merge(config)
+        validate_environment(
+            self.required_env_vars,
+            self.required_packages,
+            f"TTS Engine {self.__class__.__name__}",
+        )
 
     async def close_connection(self) -> None:
         """Cleanup the connection if necessary."""

rasa/core/information_retrieval/qdrant.py

@@ -62,6 +62,7 @@ class Qdrant_Store(InformationRetrieval):
             embeddings=self.embeddings,
             content_payload_key=params.get("content_payload_key", "text"),
             metadata_payload_key=params.get("metadata_payload_key", "metadata"),
+            vector_name=params.get("vector_name", None),
         )
 
     async def search(

rasa/core/persistor.py

@@ -4,6 +4,7 @@ import abc
 import os
 import shutil
 from enum import Enum
+from pathlib import Path
 from typing import TYPE_CHECKING, List, Optional, Text, Tuple, Union
 
 import structlog
@@ -122,7 +123,8 @@ class Persistor(abc.ABC):
 
     def persist(self, trained_model: str) -> None:
         """Uploads a trained model persisted in the `target_dir` to cloud storage."""
-        file_key = self._create_file_key(trained_model)
+        absolute_file_key = self._create_file_key(trained_model)
+        file_key = Path(absolute_file_key).name
         self._persist_tar(file_key, trained_model)
 
     def retrieve(self, model_name: Text, target_path: Text) -> Text:
@@ -141,7 +143,8 @@ class Persistor(abc.ABC):
             # ensure backward compatibility
             tar_name = self._tar_name(model_name)
         tar_name = self._create_file_key(tar_name)
-        self._retrieve_tar(tar_name)
+        target_filename = os.path.basename(tar_name)
+        self._retrieve_tar(target_filename)
         self._copy(os.path.basename(tar_name), target_path)
 
         if os.path.isdir(target_path):
@@ -149,6 +152,36 @@ class Persistor(abc.ABC):
 
         return target_path
 
+    def size_of_persisted_model(self, model_name: Text) -> int:
+        """Returns the size of the model that has been persisted to cloud storage.
+
+        Args:
+            model_name: The name of the model to retrieve.
+        """
+        tar_name = model_name
+        if not model_name.endswith(MODEL_ARCHIVE_EXTENSION):
+            # ensure backward compatibility
+            tar_name = self._tar_name(model_name)
+        tar_name = self._create_file_key(tar_name)
+        target_filename = os.path.basename(tar_name)
+        return self._retrieve_tar_size(target_filename)
+
+    def _retrieve_tar_size(self, filename: Text) -> int:
+        """Returns the size of the model that has been persisted to cloud storage."""
+        structlogger.warning(
+            "persistor.retrieve_tar_size.not_implemented",
+            filename=filename,
+            event_info=(
+                "This method should be implemented in the persistor. "
+                "The default implementation will download the model "
+                "to calculate the size. Most persistors should override "
+                "this method to avoid downloading the model and get the "
+                "size directly from the cloud storage."
+            ),
+        )
+        self._retrieve_tar(filename)
+        return os.path.getsize(os.path.basename(filename))
+
     @abc.abstractmethod
     def _retrieve_tar(self, filename: Text) -> None:
         """Downloads a model previously persisted to cloud storage."""
@@ -197,10 +230,7 @@ class Persistor(abc.ABC):
                 f"{REMOTE_STORAGE_PATH_ENV} is deprecated and will be "
                 "removed in future versions. "
                 "Please use the -m path/to/model.tar.gz option to "
-                "specify the model path when loading a model."
-                "Or use --output and --fixed-model-name to specify the "
-                "output directory and the model name when saving a "
-                "trained model to remote storage.",
+                "specify the model path when loading a model.",
             )
 
         file_key = os.path.basename(model_path)
@@ -272,50 +302,48 @@ class AWSPersistor(Persistor):
         with open(tar_path, "rb") as f:
             self.s3.Object(self.bucket_name, file_key).put(Body=f)
 
-    def _retrieve_tar(self, model_path: Text) -> None:
+    def _retrieve_tar_size(self, model_path: Text) -> int:
+        """Returns the size of the model that has been persisted to s3."""
+        try:
+            obj = self.s3.Object(self.bucket_name, model_path)
+            return obj.content_length
+        except Exception:
+            raise ModelNotFound()
+
+    def _retrieve_tar(self, target_filename: str) -> None:
         """Downloads a model that has previously been persisted to s3."""
         from botocore import exceptions
 
-        target_filename = os.path.basename(model_path)
-        bucket_objects = list(self.bucket.objects.all())
-
-        model_found = False
-
         log = (
             f"Model '{target_filename}' not found in the specified bucket "
             f"'{self.bucket_name}'. Please make sure the model exists "
             f"in the bucket."
         )
 
-        for obj in bucket_objects:
-            if model_path not in obj.key:
-                continue
+        try:
+            with open(target_filename, "wb") as f:
+                self.bucket.download_fileobj(target_filename, f)
+
             structlogger.debug(
-                "aws_persistor.retrieve_tar.object_found", object_key=obj.key
+                "aws_persistor.retrieve_tar.object_found", object_key=target_filename
             )
-
-            try:
-                with open(target_filename, "wb") as f:
-                    self.bucket.download_fileobj(obj.key, f)
-                    model_found = True
-                    break
-            except exceptions.ClientError as exc:
-                if self._error_code(exc) == HTTP_STATUS_NOT_FOUND:
-                    structlogger.error(
-                        "aws_persistor.retrieve_tar.model_not_found",
-                        bucket_name=self.bucket_name,
-                        target_filename=target_filename,
-                        event_info=log,
-                    )
-                    raise ModelNotFound() from exc
-        if not model_found:
+        except exceptions.ClientError as exc:
+            if self._error_code(exc) == HTTP_STATUS_NOT_FOUND:
+                structlogger.error(
+                    "aws_persistor.retrieve_tar.model_not_found",
+                    bucket_name=self.bucket_name,
+                    target_filename=target_filename,
+                    event_info=log,
+                )
+                raise ModelNotFound() from exc
+        except exceptions.BotoCoreError as exc:
             structlogger.error(
-                "aws_persistor.retrieve_tar.model_not_found",
+                "aws_persistor.retrieve_tar.model_download_error",
                 bucket_name=self.bucket_name,
                 target_filename=target_filename,
                 event_info=log,
             )
-            raise ModelNotFound()
+            raise ModelNotFound() from exc
 
 
 class GCSPersistor(Persistor):
@@ -397,6 +425,14 @@ class GCSPersistor(Persistor):
         blob = self.bucket.blob(file_key)
         blob.upload_from_filename(tar_path)
 
+    def _retrieve_tar_size(self, target_filename: Text) -> int:
+        """Returns the size of the model that has been persisted to GCS."""
+        try:
+            blob = self.bucket.blob(target_filename)
+            return blob.size
+        except Exception:
+            raise ModelNotFound()
+
     def _retrieve_tar(self, target_filename: Text) -> None:
         """Downloads a model that has previously been persisted to GCS."""
         from google.api_core import exceptions
@@ -404,6 +440,10 @@ class GCSPersistor(Persistor):
         blob = self.bucket.blob(target_filename)
         try:
             blob.download_to_filename(target_filename)
+
+            structlogger.debug(
+                "gcs_persistor.retrieve_tar.object_found", object_key=target_filename
+            )
         except exceptions.NotFound as exc:
             log = (
                 f"Model '{target_filename}' not found in the specified bucket "
@@ -460,24 +500,28 @@ class AzurePersistor(Persistor):
         with open(tar_path, "rb") as data:
             self._container_client().upload_blob(name=file_key, data=data)
 
-    def _retrieve_tar(self, target_filename: Text) -> None:
-        """Downloads a model that has previously been persisted to Azure."""
+    def _retrieve_tar_size(self, target_filename: Text) -> int:
+        """Returns the size of the model that has been persisted to Azure."""
         try:
-            blob_list = self._container_client().list_blobs()
-
-            for blob in blob_list:
-                if target_filename not in blob.name:
-                    continue
+            blob_client = self._container_client().get_blob_client(target_filename)
+            properties = blob_client.get_blob_properties()
+            return properties.size
+        except Exception:
+            raise ModelNotFound()
 
-                structlogger.debug(
-                    "azure_persistor.retrieve_tar.blob_found", blob_name=blob.name
-                )
+    def _retrieve_tar(self, target_filename: Text) -> None:
+        """Downloads a model that has previously been persisted to Azure."""
+        from azure.core.exceptions import AzureError
 
-                with open(target_filename, "wb") as model_file:
-                    blob_client = self._container_client().get_blob_client(blob.name)
-                    download_stream = blob_client.download_blob()
-                    model_file.write(download_stream.readall())
-        except Exception as exc:
+        try:
+            with open(target_filename, "wb") as model_file:
+                blob_client = self._container_client().get_blob_client(target_filename)
+                download_stream = blob_client.download_blob()
+                model_file.write(download_stream.readall())
+            structlogger.debug(
+                "azure_persistor.retrieve_tar.blob_found", blob_name=target_filename
+            )
+        except AzureError as exc:
             log = (
                 f"An exception occurred while trying to download "
                 f"the model '{target_filename}' in the specified container "

rasa/core/policies/flows/flow_executor.py

@@ -487,7 +487,8 @@ def validate_collect_step(
     step: CollectInformationFlowStep,
     stack: DialogueStack,
     available_actions: List[str],
-    slots: Dict[Text, Slot],
+    slots: Dict[str, Slot],
+    flow_name: str,
 ) -> bool:
     """Validate that a collect step can be executed.
 
@@ -510,12 +511,12 @@ def validate_collect_step(
         slot_name=step.collect,
     )
 
-    cancel_flow_and_push_internal_error(stack)
+    cancel_flow_and_push_internal_error(stack, flow_name)
 
     return False
 
 
-def cancel_flow_and_push_internal_error(stack: DialogueStack) -> None:
+def cancel_flow_and_push_internal_error(stack: DialogueStack, flow_name: str) -> None:
     """Cancel the top user flow and push the internal error pattern."""
     top_frame = stack.top()
 
@@ -527,7 +528,7 @@ def cancel_flow_and_push_internal_error(stack: DialogueStack) -> None:
         canceled_frames = CancelFlowCommand.select_canceled_frames(stack)
         stack.push(
             CancelPatternFlowStackFrame(
-                canceled_name=top_frame.flow_id,
+                canceled_name=flow_name,
                 canceled_frames=canceled_frames,
             )
         )
@@ -539,6 +540,7 @@ def validate_custom_slot_mappings(
     stack: DialogueStack,
     tracker: DialogueStateTracker,
     available_actions: List[str],
+    flow_name: str,
 ) -> bool:
     """Validate a slot with custom mappings.
 
@@ -559,7 +561,7 @@ def validate_custom_slot_mappings(
                     action=step.collect_action,
                     collect=step.collect,
                 )
-                cancel_flow_and_push_internal_error(stack)
+                cancel_flow_and_push_internal_error(stack, flow_name)
                 return False
 
     return True
@@ -599,7 +601,12 @@ def run_step(
 
     if isinstance(step, CollectInformationFlowStep):
         return _run_collect_information_step(
-            available_actions, initial_events, stack, step, tracker
+            available_actions,
+            initial_events,
+            stack,
+            step,
+            tracker,
+            flow.readable_name(),
         )
 
     elif isinstance(step, ActionFlowStep):
@@ -719,15 +726,18 @@ def _run_collect_information_step(
     stack: DialogueStack,
     step: CollectInformationFlowStep,
     tracker: DialogueStateTracker,
+    flow_name: str,
 ) -> FlowStepResult:
-    is_step_valid = validate_collect_step(step, stack, available_actions, tracker.slots)
+    is_step_valid = validate_collect_step(
+        step, stack, available_actions, tracker.slots, flow_name
+    )
 
     if not is_step_valid:
         # if we return any other FlowStepResult, the assistant will stay silent
         # instead of triggering the internal error pattern
         return ContinueFlowWithNextStep(events=initial_events)
     is_mapping_valid = validate_custom_slot_mappings(
-        step, stack, tracker, available_actions
+        step, stack, tracker, available_actions, flow_name
     )
 
     if not is_mapping_valid:

rasa/core/processor.py

@@ -1279,11 +1279,13 @@ class MessageProcessor:
             tracker.update(events[0])
             return self.should_predict_another_action(action.name())
         except Exception:
-            logger.exception(
-                f"Encountered an exception while running action '{action.name()}'."
-                "Bot will continue, but the actions events are lost. "
-                "Please check the logs of your action server for "
-                "more information."
+            structlogger.exception(
+                "rasa.core.processor.run_action.exception",
+                event_info=f"Encountered an exception while "
+                f"running action '{action.name()}'."
+                f"Bot will continue, but the actions events are lost. "
+                f"Please check the logs of your action server for "
+                f"more information.",
             )
             events = []
 

rasa/e2e_test/aggregate_test_stats_calculator.py

@@ -35,6 +35,7 @@ class AggregateTestStatsCalculator:
         self.test_cases = test_cases
 
         self.failed_assertion_set: Set["Assertion"] = set()
+        self.failed_test_cases_without_assertion_failure: Set[str] = set()
         self.passed_count_mapping = {
             subclass_type: 0
             for subclass_type in _get_all_assertion_subclasses().keys()
@@ -89,8 +90,14 @@ class AggregateTestStatsCalculator:
         passed_test_case_names = [
             passed.test_case.name for passed in self.passed_results
         ]
+        # We filter out test cases that failed without an assertion failure
+        filtered_test_cases = [
+            test_case
+            for test_case in self.test_cases
+            if test_case.name not in self.failed_test_cases_without_assertion_failure
+        ]
 
-        for test_case in self.test_cases:
+        for test_case in filtered_test_cases:
             if test_case.name in passed_test_case_names:
                 for step in test_case.steps:
                     if step.assertions is None:
@@ -118,6 +125,9 @@ class AggregateTestStatsCalculator:
                     "no_assertion_failure_in_failed_result",
                     test_case=failed.test_case.name,
                 )
+                self.failed_test_cases_without_assertion_failure.add(
+                    failed.test_case.name
+                )
                 continue
 
             self.failed_assertion_set.add(failed.assertion_failure.assertion)