code: def test_process_unpacks_attributes_from_single_message_and_fallsback_if_needed(
      confidence: Optional[Text],
      entities: Optional[Text],
      expected_confidence: float,
      expected_entities: Optional[List[Dict[Text, Any]]],
      should_warn: bool,
  ):
      # dummy intent
      expected_intent = "my-intent"
  
      # construct text according to pattern
      text = " \t  " + INTENT_MESSAGE_PREFIX + expected_intent
      if confidence is not None:
          text += f"@{confidence}"
      if entities is not None:
          text += entities
      text += " \t "
  
      # create a message with some dummy attributes and features
      message = Message(
          data={
              TEXT: text,
              INTENT: "extracted-from-the-pattern-text-via-nlu",
          },
          features=[
              Features(
                  features=np.zeros((1, 1)),
                  feature_type=FEATURE_TYPE_SENTENCE,
                  attribute=TEXT,
                  origin="nlu-pipeline",
              )
          ],
      )
  
      # construct domain from expected intent/entities
      domain_entities = [
          item[ENTITY_ATTRIBUTE_TYPE] for item in expected_entities
      ]
      domain_intents = (
          [expected_intent] if expected_intent is not None else []
      )
      domain = Domain(
          intents=domain_intents,
          entities=domain_entities,
          slots=[],
          responses={},
          action_names=[],
          forms={},
          data={},
      )
  
      # extract information
      if should_warn:
          with pytest.warns(UserWarning):
              unpacked_message = YAMLStoryReader.unpack_regex_message(
                  message, domain
              )
      else:
          unpacked_message = YAMLStoryReader.unpack_regex_message(
              message, domain
          )
  
      assert not unpacked_message.features
  
      assert set(unpacked_message.data.keys()) == {
          TEXT,
          INTENT,
          INTENT_RANKING_KEY,
          ENTITIES,
      }
  
      assert unpacked_message.data[TEXT] == message.data[TEXT].strip()
  
      assert set(unpacked_message.data[INTENT].keys()) == {
          INTENT_NAME_KEY,
          PREDICTED_CONFIDENCE_KEY,
      }
      assert (
          unpacked_message.data[INTENT][INTENT_NAME_KEY]
          == expected_intent
      )
      assert (
          unpacked_message.data[INTENT][PREDICTED_CONFIDENCE_KEY]
          == expected_confidence
      )
  
      intent_ranking = unpacked_message.data[INTENT_RANKING_KEY]
      assert len(intent_ranking) == 1
      assert intent_ranking[0] == {
          INTENT_NAME_KEY: expected_intent,
          PREDICTED_CONFIDENCE_KEY: expected_confidence,
      }
      if expected_entities:
          entity_data: List[Dict[Text, Any]] = unpacked_message.data[
              ENTITIES
          ]
          assert all(
              set(item.keys())
              == {
                  ENTITY_ATTRIBUTE_VALUE,
                  ENTITY_ATTRIBUTE_TYPE,
                  ENTITY_ATTRIBUTE_START,
                  ENTITY_ATTRIBUTE_END,
              }
              for item in entity_data
          )
          assert set(
              (
                  item[ENTITY_ATTRIBUTE_TYPE],
                  item[ENTITY_ATTRIBUTE_VALUE],
              )
              for item in expected_entities
          ) == set(
              (
                  item[ENTITY_ATTRIBUTE_TYPE],
                  item[ENTITY_ATTRIBUTE_VALUE],
              )
              for item in entity_data
          )
      else:
          assert unpacked_message.data[ENTITIES] is not None
          assert len(unpacked_message.data[ENTITIES]) == 0
  
imports: import json
  import warnings
  import numpy
  import os
  import pytest
  import sys
  from collections import Counter
  from pathlib import Path
  from typing import Any, Text, List, Dict, Optional
  from _pytest.monkeypatch import MonkeyPatch
  from unittest.mock import Mock
  from rasa.shared.nlu.training_data.features import Features
  from rasa.shared.nlu.training_data.message import Message
  import rasa.shared.utils.io
  from rasa.shared.exceptions import FileNotFoundException, YamlSyntaxException, YamlException
  from rasa.core.actions.action import ACTION_LISTEN_NAME
  from rasa.core import training
  from rasa.core.featurizers.tracker_featurizers import MaxHistoryTrackerFeaturizer
  from rasa.core.featurizers.single_state_featurizer import SingleStateFeaturizer
  from rasa.utils.tensorflow.model_data_utils import _surface_attributes
  from rasa.shared.constants import INTENT_MESSAGE_PREFIX, LATEST_TRAINING_DATA_FORMAT_VERSION
  from rasa.shared.core.constants import RULE_SNIPPET_ACTION_NAME
  from rasa.shared.core.domain import Domain
  from rasa.shared.core.training_data import loading
  from rasa.shared.core.events import ActionExecuted, UserUttered, SlotSet, ActiveLoop
  from rasa.shared.core.training_data.story_reader.yaml_story_reader import YAMLStoryReader, DEFAULT_VALUE_TEXT_SLOTS
  from rasa.shared.core.training_data.structures import StoryStep, RuleStep
  from rasa.shared.nlu.constants import ACTION_NAME, ENTITIES, ENTITY_ATTRIBUTE_END, ENTITY_ATTRIBUTE_START, ENTITY_ATTRIBUTE_TYPE, ENTITY_ATTRIBUTE_VALUE, FEATURE_TYPE_SENTENCE, INTENT, INTENT_NAME_KEY, INTENT_RANKING_KEY, PREDICTED_CONFIDENCE_KEY, TEXT, EXTRACTOR
  from tests.conftest import filter_expected_warnings
label_desc: Use image node_id 37 for calling a global function with example usage: test_process_unpacks_attributes_from_single_message_and_fallsback_if_needed(confidence, entities, expected_confidence, expected_entities, should_warn) without return types