rasa-pro 3.12.22__py3-none-any.whl → 3.13.0__py3-none-any.whl

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -4,32 +4,22 @@ from typing import Any, Dict, Literal, Optional, Text
 import structlog
 
 from rasa.dialogue_understanding.commands.command_syntax_manager import (
-    CommandSyntaxManager,
     CommandSyntaxVersion,
 )
-from rasa.dialogue_understanding.generator.constants import (
-    DEFAULT_LLM_CONFIG,
-    FLOW_RETRIEVAL_KEY,
-    LLM_CONFIG_KEY,
-    USER_INPUT_CONFIG_KEY,
-)
-from rasa.dialogue_understanding.generator.flow_retrieval import FlowRetrieval
-from rasa.dialogue_understanding.generator.single_step.compact_llm_command_generator import (  # noqa: E501
-    CompactLLMCommandGenerator,
+from rasa.dialogue_understanding.generator.single_step.single_step_based_llm_command_generator import (  # noqa: E501
+    SingleStepBasedLLMCommandGenerator,
 )
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.constants import (
-    EMBEDDINGS_CONFIG_KEY,
     PROMPT_CONFIG_KEY,
     PROMPT_TEMPLATE_CONFIG_KEY,
 )
-from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
-from rasa.shared.utils.io import deep_container_fingerprint
+from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.shared.utils.llm import (
+    check_prompt_config_keys_and_warn_if_deprecated,
     get_prompt_template,
-    resolve_model_client_config,
 )
 
 DEFAULT_COMMAND_PROMPT_TEMPLATE = importlib.resources.read_text(
@@ -47,7 +37,7 @@ structlogger = structlog.get_logger()
     ],
     is_trainable=True,
 )
-class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
+class SingleStepLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
     """A single step LLM-based command generator."""
 
     def __init__(
@@ -58,6 +48,14 @@ class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
         prompt_template: Optional[Text] = None,
         **kwargs: Any,
     ) -> None:
+        raise_deprecation_warning(
+            message=(
+                "Support for `SingleStepLLMCommandGenerator` will be removed in Rasa "
+                "`4.0.0`. Please modify your assistant's configuration to use the "
+                "`CompactLLMCommandGenerator` or `SearchReadyLLMCommandGenerator` "
+                "instead."
+            )
+        )
         super().__init__(
             config,
             model_storage,
@@ -66,64 +64,22 @@ class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
             **kwargs,
         )
 
-        # Set the prompt template
-        if config.get(PROMPT_CONFIG_KEY):
-            structlogger.warning(
-                "single_step_llm_command_generator.init",
-                event_info=(
-                    "The config parameter 'prompt' is deprecated "
-                    "and will be removed in Rasa 4.0.0. "
-                    "Please use the config parameter 'prompt_template' instead. "
-                ),
-            )
-
-        # Set the command syntax version to v1
-        CommandSyntaxManager.set_syntax_version(
-            self.get_component_command_syntax_version()
+        # Warn if the prompt config key is used to set the prompt template
+        check_prompt_config_keys_and_warn_if_deprecated(
+            config, "single_step_llm_command_generator"
         )
 
-    @staticmethod
-    def get_default_config() -> Dict[str, Any]:
-        """The component's default config (see parent class for full docstring)."""
-        return {
-            PROMPT_CONFIG_KEY: None,  # Legacy
-            PROMPT_TEMPLATE_CONFIG_KEY: None,
-            USER_INPUT_CONFIG_KEY: None,
-            LLM_CONFIG_KEY: None,
-            FLOW_RETRIEVAL_KEY: FlowRetrieval.get_default_config(),
-        }
-
-    @classmethod
-    def fingerprint_addon(cls: Any, config: Dict[str, Any]) -> Optional[str]:
-        """Add a fingerprint for the graph."""
-        prompt_template = cls._resolve_component_prompt_template(
-            config, log_context=LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
-        )
-        llm_config = resolve_model_client_config(
-            config.get(LLM_CONFIG_KEY), SingleStepLLMCommandGenerator.__name__
-        )
-        embedding_config = resolve_model_client_config(
-            config.get(FLOW_RETRIEVAL_KEY, {}).get(EMBEDDINGS_CONFIG_KEY),
-            FlowRetrieval.__name__,
-        )
-        return deep_container_fingerprint(
-            [prompt_template, llm_config, embedding_config]
-        )
-
-    @staticmethod
-    def get_default_llm_config() -> Dict[str, Any]:
-        """Get the default LLM config for the command generator."""
-        return DEFAULT_LLM_CONFIG
-
     @staticmethod
     def get_component_command_syntax_version() -> CommandSyntaxVersion:
         return CommandSyntaxVersion.v1
 
-    @staticmethod
+    @classmethod
     def _resolve_component_prompt_template(
+        cls: Any,
         config: Dict[str, Any],
         prompt_template: Optional[str] = None,
         log_context: Optional[Literal["init", "fingerprint_addon"]] = None,
+        log_source_component: Optional[str] = "SingleStepLLMCommandGenerator",
     ) -> Optional[str]:
         """Get the prompt template from the config or the default prompt template."""
         # Case when model is being loaded
@@ -143,6 +99,6 @@ class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
         return get_prompt_template(
             prompt_template_path,
             DEFAULT_COMMAND_PROMPT_TEMPLATE,
-            log_source_component=SingleStepLLMCommandGenerator.__name__,
+            log_source_component=log_source_component,
             log_source_method=log_context,
         )

rasa/dialogue_understanding/patterns/cancel.py

@@ -90,7 +90,7 @@ class ActionCancelFlow(action.Action):
             return []
 
         if not isinstance(top, CancelPatternFlowStackFrame):
-            structlogger.warning("action.cancel_flow.no_cancel_frame", top=top)
+            structlogger.warning("action.cancel_flow.no_cancel_frame")
             return []
 
         for canceled_frame_id in top.canceled_frames:
@@ -105,7 +105,6 @@ class ActionCancelFlow(action.Action):
             else:
                 structlogger.warning(
                     "action.cancel_flow.frame_not_found",
-                    dialogue_stack=stack,
                     frame_id=canceled_frame_id,
                 )
 

rasa/dialogue_understanding/patterns/clarify.py

@@ -89,7 +89,7 @@ class ActionClarifyFlows(action.Action):
             return []
 
         if not isinstance(top, ClarifyPatternFlowStackFrame):
-            structlogger.warning("action.clarify_flows.no_clarification_frame", top=top)
+            structlogger.warning("action.clarify_flows.no_clarification_frame")
             return []
 
         options_string = self.assemble_options_string(top.names)

rasa/dialogue_understanding/patterns/correction.py

@@ -114,7 +114,8 @@ class ActionCorrectFlowSlot(action.Action):
 
         if not isinstance(top, CorrectionPatternFlowStackFrame):
             structlogger.warning(
-                "action.correct_flow_slot.no_correction_frame", top=top
+                "action.correct_flow_slot.no_correction_frame",
+                top=top,  # no PII
             )
             return []
 
@@ -246,7 +247,6 @@ def reset_stack_on_tracker_to_prior_state(
             "action.correct_flow_slot.no_target_frame_found",
             reset_step_id=reset_step_id,
             reset_flow_id=reset_flow_id,
-            stack_to_reset_to=stack_to_reset_to,
         )
         return tracker.stack
 

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -93,6 +93,11 @@ responses:
       metadata:
         rephrase: True
 
+  utter_no_relevant_answer_found:
+    - text: I’m sorry, I can’t help with that.
+      metadata:
+        rephrase: True
+
   utter_skip_question_answer:
     - text: I'm here to provide you with the best assistance, and in order to do so, I kindly request that we complete this step together. Your input is essential for a seamless experience!
       metadata:
@@ -129,23 +134,29 @@ flows:
       - action: utter_flow_cancelled_rasa
 
   pattern_cannot_handle:
-    description: |
-      Conversation repair flow for addressing failed command generation scenarios
-    name: pattern cannot handle
+    description: Conversation repair flow for addressing failed command generation scenarios
+    name: pattern_cannot_handle
     steps:
       - noop: true
         next:
-          # chitchat fallback
-          - if: "'{{context.reason}}' = 'cannot_handle_chitchat'"
+          # Fallback for ChitChat command when IntentlessPolicy isn't set, but
+          # pattern_chitchat invokes action_trigger_chitchat
+          - if: context.reason is "cannot_handle_chitchat"
             then:
               - action: utter_cannot_handle
                 next: "END"
-          # fallback for things that are not supported
-          - if: "'{{context.reason}}' = 'cannot_handle_not_supported'"
+          # Fallback for things that are not supported
+          - if: context.reason is "cannot_handle_not_supported"
             then:
               - action: utter_cannot_handle
                 next: END
-          # default
+          # Fallback when no relevant answer to the user query has been found.
+          # This is used by the EnterpriseSearchPolicy.
+          - if: context.reason is "cannot_handle_no_relevant_answer"
+            then:
+              - action: utter_no_relevant_answer_found
+                next: END
+          # Default
           - else:
               - action: utter_ask_rephrase
                 next: END
@@ -154,7 +165,9 @@ flows:
     description: Conversation repair flow for off-topic interactions that won't disrupt the main conversation
     name: pattern chitchat
     steps:
-      - action: action_trigger_chitchat
+      - action: utter_cannot_handle
+      # To enable free-form response use:
+      # - action: utter_free_chitchat_response
 
   pattern_clarification:
     description: Conversation repair flow for handling ambiguous requests that could match multiple flows
@@ -219,15 +232,15 @@ flows:
 
   pattern_internal_error:
     description: Conversation repair flow for informing users about internal errors
-    name: pattern internal error
+    name: pattern_internal_error
     steps:
       - noop: true
         next:
-          - if: "'{{context.error_type}}' = 'rasa_internal_error_user_input_too_long'"
+          - if: context.error_type is "rasa_internal_error_user_input_too_long"
             then:
               - action: utter_user_input_too_long_error_rasa
                 next: END
-          - if: "'{{context.error_type}}' = 'rasa_internal_error_user_input_empty'"
+          - if: context.error_type is "rasa_internal_error_user_input_empty"
             then:
               - action: utter_user_input_empty_error_rasa
                 next: END
@@ -236,7 +249,7 @@ flows:
                 next: END
 
   pattern_repeat_bot_messages:
-    description: Voice conversation repair pattern to repeat bot messages
+    description: Conversation repair flow for repeating previous messages
     name: pattern repeat bot messages
     steps:
       - action: action_repeat_bot_messages
@@ -281,23 +294,25 @@ flows:
       - noop: true
         next:
           - if: "slots.consecutive_silence_timeouts = 0.0"
-            then:
-              - set_slots:
-                  - consecutive_silence_timeouts: 1.0
-              - action: action_repeat_bot_messages
-                next: END
+            then: set_slots_consecutive_silence_timeouts
           - if: "slots.consecutive_silence_timeouts = 1.0"
-            then:
-              - set_slots:
-                  - consecutive_silence_timeouts: 2.0
-              - action: utter_ask_still_there
-                next: END
+            then: set_slots_consecutive_silence_timeouts_2
           - if: "slots.consecutive_silence_timeouts > 1.0"
-            then:
-              - action: utter_inform_hangup
-              - action: action_hangup
-                next: END
+            then: message_utter_inform_hangup
           - else: END
+      - id: set_slots_consecutive_silence_timeouts
+        set_slots:
+          - consecutive_silence_timeouts: 1.0
+      - action: action_repeat_bot_messages
+        next: END
+      - id: set_slots_consecutive_silence_timeouts_2
+        set_slots:
+          - consecutive_silence_timeouts: 2.0
+      - action: utter_ask_still_there
+        next: END
+      - id: message_utter_inform_hangup
+        action: utter_inform_hangup
+      - action: action_hangup
 
   pattern_validate_slot:
     description: Flow for running validations on slots

rasa/dialogue_understanding/patterns/domain_for_patterns.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import os
+from dataclasses import fields, is_dataclass
+from typing import Any, Dict, List, Optional, Set, Text
+
+import importlib_resources
+from pydantic import BaseModel, Field, ValidationInfo, field_validator
+
+from rasa.dialogue_understanding.stack.frames.pattern_frame import PatternFlowStackFrame
+from rasa.shared.core.constants import (
+    DEFAULT_ACTION_NAMES,
+    DEFAULT_INTENTS,
+    RULE_SNIPPET_ACTION_NAME,
+)
+from rasa.shared.core.slots import AnySlot, BooleanSlot, CategoricalSlot, TextSlot
+
+ACTIONS: List[Text] = [
+    *DEFAULT_ACTION_NAMES,
+    "validate_{{context.collect}}",
+]
+EXCLUDED_ACTIONS: Set[Text] = {RULE_SNIPPET_ACTION_NAME}
+
+INTENTS: List[Text] = [*DEFAULT_INTENTS]
+
+CONTEXT_FIELD_TYPES: Dict[Text, Text] = {
+    "canceled_name": CategoricalSlot.type_name,
+    "names": CategoricalSlot.type_name,
+    "collect": CategoricalSlot.type_name,
+    "utter": CategoricalSlot.type_name,
+    "collect_action": CategoricalSlot.type_name,
+    "previous_flow_name": CategoricalSlot.type_name,
+    "reset_flow_id": CategoricalSlot.type_name,
+    "is_reset_only": BooleanSlot.type_name,
+    "canceled_frames": AnySlot.type_name,
+    "corrected_slots": AnySlot.type_name,
+    "rejections": AnySlot.type_name,
+    "info": AnySlot.type_name,
+    "reason": TextSlot.type_name,
+    "error_type": TextSlot.type_name,
+}
+
+FLOW_NAME_VALUES = "FLOW_NAME"
+FLOW_ID_VALUES = "FLOW_ID"
+SLOT_NAME_VALUES = "SLOT_NAME"
+RESPONSE_NAME_VALUES = "RESPONSE_NAME"
+ACTION_NAME_VALUES = "ACTION_NAME"
+
+CONTEXT_FIELD_VALUES: Dict[Text, Text] = {
+    "canceled_name": FLOW_NAME_VALUES,
+    "names": FLOW_NAME_VALUES,
+    "previous_flow_name": FLOW_NAME_VALUES,
+    "reset_flow_id": FLOW_ID_VALUES,
+    "collect": SLOT_NAME_VALUES,
+    "utter": RESPONSE_NAME_VALUES,
+    "collect_action": ACTION_NAME_VALUES,
+}
+
+PATTERNS_MODULE_BASE = "rasa.dialogue_understanding.patterns"
+
+
+class ContextField(BaseModel):
+    """Element in the `contexts` mapping of the domain."""
+
+    patterns: List[Text] = Field(
+        ..., description="Patterns that reference this context field."
+    )
+    type: Text = Field(
+        ..., description="Slot type (categorical, text, boolean, any …)."
+    )
+    values: Optional[List[Text]] = Field(
+        None,
+        description="Optional placeholder that restricts which values a slot can take "
+        "(FLOW_NAME, SLOT_NAME, …).",
+    )
+
+    @field_validator("type")
+    def _validate_slot_type(cls, v: str) -> str:
+        allowed_types = list(set(CONTEXT_FIELD_TYPES.values()))
+        if v not in allowed_types:
+            raise ValueError(
+                f"Unsupported type '{v}'. "
+                f"Must be one of: {', '.join(allowed_types)}."
+            )
+        return v
+
+    @field_validator("values")
+    def _validate_values_placeholder(
+        cls, v: Optional[str], values: ValidationInfo
+    ) -> Optional[str]:
+        if v is None:
+            return v
+
+        allowed_values = set(CONTEXT_FIELD_VALUES.values())
+        if not set(v).issubset(allowed_values):
+            raise ValueError(
+                f"Unsupported values placeholder '{v}'. "
+                f"Must be one of {', '.join(allowed_values)}."
+            )
+
+        slot_type = values.data.get("type")
+        if slot_type != CategoricalSlot.type_name:
+            raise ValueError(
+                "`values` can only be specified for categorical slots "
+                f"(got slot type '{slot_type}')."
+            )
+
+        return v
+
+
+class PatternDomain(BaseModel):
+    """Complete domain that is generated for the default patterns."""
+
+    actions: List[Text]
+    intents: List[Text]
+    contexts: Dict[Text, ContextField]
+
+
+def build_contexts_from_patterns() -> Dict[str, Dict[str, Any]]:
+    """Builds a dictionary of contexts from the pattern classes.
+
+    Returns:
+        A dictionary where each key is a field name and the value is a dictionary
+    """
+    patterns_folder = str(importlib_resources.files(PATTERNS_MODULE_BASE))
+    contexts_map: Dict[str, Dict[str, Any]] = {}
+
+    # Dynamically gather all .py files
+    for root, _, files in os.walk(patterns_folder):
+        for file in files:
+            if not file.endswith(".py"):
+                continue
+
+            try:
+                module_name = f"{PATTERNS_MODULE_BASE}.{file[:-3]}"
+                module = importlib.import_module(module_name)
+            except ImportError:
+                continue
+
+            # Inspect classes in that module
+            for _, cls in inspect.getmembers(module, inspect.isclass):
+                if not is_dataclass(cls):
+                    continue
+
+                # The cls has to be a subclass of PatternFlowStackFrame
+                if cls == PatternFlowStackFrame or not issubclass(
+                    cls, PatternFlowStackFrame
+                ):
+                    continue
+
+                for f in fields(cls):
+                    field_name = f.name
+                    if field_name not in contexts_map:
+                        field_type = CONTEXT_FIELD_TYPES.get(
+                            field_name, TextSlot.type_name
+                        )
+                        contexts_map[field_name] = {
+                            "patterns": set(),
+                            "type": field_type,
+                        }
+                        values: Optional[Text] = CONTEXT_FIELD_VALUES.get(field_name)
+                        if values:
+                            contexts_map[field_name]["values"] = [values]
+
+                    # Add the pattern name to the set
+                    pattern_name = cls.type()
+                    contexts_map[field_name]["patterns"].add(pattern_name)
+
+    # Convert "patterns" from set to list, for a clean final structure
+    for field_name, details in contexts_map.items():
+        details["patterns"] = sorted(list(details["patterns"]))
+
+    return contexts_map
+
+
+def generate_domain_for_default_patterns() -> PatternDomain:
+    """
+    Generate the domain for pattern-based flows as a strongly-typed object.
+
+    Returns: PatternDomain Pydantic model containing actions, intents and contexts.
+    """
+    actions = [action for action in ACTIONS if action not in EXCLUDED_ACTIONS]
+    raw_contexts = build_contexts_from_patterns()
+    contexts = {
+        field_name: ContextField(**details)
+        for field_name, details in raw_contexts.items()
+    }
+    return PatternDomain(actions=actions, intents=INTENTS, contexts=contexts)

rasa/dialogue_understanding/processor/command_processor.py

@@ -126,7 +126,7 @@ def validate_state_of_commands(commands: List[Command]) -> None:
     if sum(isinstance(c, CancelFlowCommand) for c in commands) > 1:
         structlogger.error(
             "command_processor.validate_state_of_commands.multiple_cancel_flow_commands",
-            commands=commands,
+            commands=[command.__class__.__name__ for command in commands],
         )
         raise ValueError("There can only be one cancel flow command.")
 
@@ -137,7 +137,7 @@ def validate_state_of_commands(commands: List[Command]) -> None:
     if free_form_answer_commands != commands[: len(free_form_answer_commands)]:
         structlogger.error(
             "command_processor.validate_state_of_commands.free_form_answer_commands_not_at_beginning",
-            commands=commands,
+            commands=[command.__class__.__name__ for command in commands],
         )
         raise ValueError(
             "Free form answer commands must be at start of the predicted command list."
@@ -147,7 +147,7 @@ def validate_state_of_commands(commands: List[Command]) -> None:
     if sum(isinstance(c, CorrectSlotsCommand) for c in commands) > 1:
         structlogger.error(
             "command_processor.validate_state_of_commands.multiple_correct_slots_commands",
-            commands=commands,
+            commands=[command.__class__.__name__ for command in commands],
         )
         raise ValueError("There can only be one correct slots command.")
 
@@ -342,7 +342,6 @@ def get_current_collect_step(
         # but no flow that triggered it. this should never happen.
         structlogger.warning(
             "command_processor.get_current_collect_step.no_flow_on_stack",
-            stack=dialogue_stack,
         )
         return None
 
@@ -352,7 +351,7 @@ def get_current_collect_step(
         # step from it
         structlogger.warning(
             "command_processor.get_current_collect_step.no_step_for_frame",
-            frame=frame_that_triggered_collect_infos,
+            frame=frame_that_triggered_collect_infos.frame_id,
         )
         return None
 
@@ -726,7 +725,7 @@ def clean_up_chitchat_command(
         )
         structlogger.warn(
             "command_processor.clean_up_chitchat_command.pattern_chitchat_not_found",
-            command=resulting_commands[0],
+            command=resulting_commands[0],  # no PII
         )
         return resulting_commands
 
@@ -744,7 +743,7 @@ def clean_up_chitchat_command(
         )
         structlogger.warn(
             "command_processor.clean_up_chitchat_command.replace_chitchat_answer_with_cannot_handle",
-            command=resulting_commands[0],
+            command=resulting_commands[0],  # no PII
             pattern_chitchat_uses_action_trigger_chitchat=has_action_trigger_chitchat,
             defined_intentless_policy_in_config=defines_intentless_policy,
         )

rasa/dialogue_understanding_test/command_metric_calculation.py

@@ -1,54 +1,21 @@
+import typing
 from collections import defaultdict
 from typing import Dict, List
 
-from pydantic import BaseModel
-
 from rasa.dialogue_understanding.commands import Command
 from rasa.dialogue_understanding_test.command_comparison import (
     is_command_present_in_list,
 )
-from rasa.dialogue_understanding_test.du_test_result import (
-    DialogueUnderstandingTestResult,
-)
-
-
-class CommandMetrics(BaseModel):
-    tp: int
-    fp: int
-    fn: int
-    total_count: int
-
-    @staticmethod
-    def _safe_divide(numerator: float, denominator: float) -> float:
-        """Safely perform division, returning 0.0 if the denominator is zero."""
-        return numerator / denominator if denominator > 0 else 0.0
+from rasa.dialogue_understanding_test.command_metrics import CommandMetrics
 
-    def get_precision(self) -> float:
-        return self._safe_divide(self.tp, self.tp + self.fp)
-
-    def get_recall(self) -> float:
-        return self._safe_divide(self.tp, self.tp + self.fn)
-
-    def get_f1_score(self) -> float:
-        precision = self.get_precision()
-        recall = self.get_recall()
-
-        return self._safe_divide(2 * precision * recall, precision + recall)
-
-    def as_dict(self) -> Dict[str, float]:
-        return {
-            "tp": self.tp,
-            "fp": self.fp,
-            "fn": self.fn,
-            "precision": self.get_precision(),
-            "recall": self.get_recall(),
-            "f1_score": self.get_f1_score(),
-            "total_count": self.total_count,
-        }
+if typing.TYPE_CHECKING:
+    from rasa.dialogue_understanding_test.du_test_result import (
+        DialogueUnderstandingTestResult,
+    )
 
 
 def calculate_command_metrics(
-    test_results: List[DialogueUnderstandingTestResult],
+    test_results: List["DialogueUnderstandingTestResult"],
 ) -> Dict[str, CommandMetrics]:
     """Calculate the command metrics for the test result."""
     metrics: Dict[str, CommandMetrics] = defaultdict(

rasa/dialogue_understanding_test/command_metrics.py

@@ -0,0 +1,38 @@
+from typing import Dict
+
+from pydantic import BaseModel
+
+
+class CommandMetrics(BaseModel):
+    tp: int
+    fp: int
+    fn: int
+    total_count: int
+
+    @staticmethod
+    def _safe_divide(numerator: float, denominator: float) -> float:
+        """Safely perform division, returning 0.0 if the denominator is zero."""
+        return numerator / denominator if denominator > 0 else 0.0
+
+    def get_precision(self) -> float:
+        return self._safe_divide(self.tp, self.tp + self.fp)
+
+    def get_recall(self) -> float:
+        return self._safe_divide(self.tp, self.tp + self.fn)
+
+    def get_f1_score(self) -> float:
+        precision = self.get_precision()
+        recall = self.get_recall()
+
+        return self._safe_divide(2 * precision * recall, precision + recall)
+
+    def as_dict(self) -> Dict[str, float]:
+        return {
+            "tp": self.tp,
+            "fp": self.fp,
+            "fn": self.fn,
+            "precision": self.get_precision(),
+            "recall": self.get_recall(),
+            "f1_score": self.get_f1_score(),
+            "total_count": self.total_count,
+        }