code: def test_encode_state__with_lookup__looksup_or_creates_features(
      action_name: Text,
  ):
      """Tests that features from table are combined or created from scratch.
      If the given action name is ...
      - ACTION_LISTEN_NAME then the user substate and the action name are encoded
      - some "other" action, then the user-substate is not encoed but the action name is
      - set to "None", then we remove the action name from the user substate and as a
        result there should be no encoding for the action name and for the user substate
      """
      f = SingleStateFeaturizer()
      f._default_feature_states[INTENT] = {"greet": 0, "inform": 1}
      f._default_feature_states[ENTITIES] = {
          "city": 0,
          "name": 1,
          f"city{ENTITY_LABEL_SEPARATOR}to": 2,
          f"city{ENTITY_LABEL_SEPARATOR}from": 3,
      }
      f._default_feature_states[ACTION_NAME] = {
          "NOT_action_listen": 0,
          "utter_greet": 1,
          ACTION_LISTEN_NAME: 2,
      }
      # `_0` in slots represent feature dimension
      f._default_feature_states[SLOTS] = {
          "slot_1_0": 0,
          "slot_2_0": 1,
          "slot_3_0": 2,
      }
      f._default_feature_states[ACTIVE_LOOP] = {
          "active_loop_1": 0,
          "active_loop_2": 1,
          "active_loop_3": 2,
          "active_loop_4": 3,
      }
  
      # create state
      text = "I am flying from London to Paris"
      tokens = [
          Token(text=match.group(), start=match.start())
          for match in re.finditer(r"\S+", text)
      ]
      entity_name_list = ["city", f"city{ENTITY_LABEL_SEPARATOR}to"]
      action_text = "throw a ball"
      intent = "inform"
      state = {
          USER: {
              TEXT: text,
              INTENT: intent,
              ENTITIES: entity_name_list,
          },
          PREVIOUS_ACTION: {
              ACTION_NAME: action_name,
              ACTION_TEXT: action_text,
          },
          ACTIVE_LOOP: {"name": "active_loop_4"},
          SLOTS: {"slot_1": (1.0,)},
      }
      if action_name is None:
          del state[PREVIOUS_ACTION][ACTION_NAME]
  
      # Build lookup table with all relevant information - and dummy features for all
      # dense featurizable attributes.
      # Note that we don't need to add the `ENTITIES` to the message including `TEXT`
      # here because `encode_state` won't featurize the entities using the lookup table
      # (only `encode_entities` does that).
      units = 300
      precomputations = MessageContainerForCoreFeaturization()
      precomputations.add_all(
          [
              Message(
                  data={TEXT: text, TOKENS_NAMES[TEXT]: tokens},
                  features=[
                      dummy_features(
                          fill_value=11,
                          units=units,
                          attribute=TEXT,
                          type=SENTENCE,
                          is_sparse=True,
                      ),
                      dummy_features(
                          fill_value=12,
                          units=units,
                          attribute=TEXT,
                          type=SEQUENCE,
                          is_sparse=False,
                      ),
                      # Note: sparse sequence feature is last here
                      dummy_features(
                          fill_value=13,
                          units=units,
                          attribute=TEXT,
                          type=SEQUENCE,
                          is_sparse=True,
                      ),
                  ],
              ),
              Message(data={INTENT: intent}),
              Message(
                  data={ACTION_TEXT: action_text},
                  features=[
                      dummy_features(
                          fill_value=1,
                          units=units,
                          attribute=ACTION_TEXT,
                          type=SEQUENCE,
                          is_sparse=True,
                      )
                  ],
              ),
          ]
      )
      if action_name is not None:
          precomputations.add(Message(data={ACTION_NAME: action_name}))
  
      # encode the state
      encoded = f.encode_state(state, precomputations=precomputations)
  
      # check all the features are encoded and *_text features are encoded by a
      # dense featurizer
      expected_attributes = [SLOTS, ACTIVE_LOOP, ACTION_TEXT]
      if (
          action_name is not None
      ):  # i.e. we did not remove it from the state
          expected_attributes += [ACTION_NAME]
      if action_name == ACTION_LISTEN_NAME:
          expected_attributes += [TEXT, ENTITIES, INTENT]
      assert set(encoded.keys()) == set(expected_attributes)
  
      # Remember, sparse sequence features come first (and `.features` denotes the matrix
      # not a `Features` object)
      if action_name == ACTION_LISTEN_NAME:
          assert encoded[TEXT][0].features.shape[-1] == units
          assert encoded[TEXT][0].is_sparse()
          assert encoded[ENTITIES][0].features.shape[-1] == 4
          assert sparse_equals_dense(
              encoded[INTENT][0].features, np.array([[0, 1]])
          )
      assert encoded[ACTION_TEXT][0].features.shape[-1] == units
      assert encoded[ACTION_TEXT][0].is_sparse()
      if action_name is not None:
          if action_name == "NOT_action_listen":
              action_name_encoding = [1, 0, 0]
          else:  # action_listen
              action_name_encoding = [0, 0, 1]
          assert sparse_equals_dense(
              encoded[ACTION_NAME][0].features,
              np.array([action_name_encoding]),
          )
      else:
          assert ACTION_NAME not in encoded
      assert sparse_equals_dense(
          encoded[SLOTS][0].features, np.array([[1, 0, 0]])
      )
      assert sparse_equals_dense(
          encoded[ACTIVE_LOOP][0].features, np.array([[0, 0, 0, 1]])
      )
  
imports: from typing import Text
  import numpy
  import re
  import scipy.sparse
  import pytest
  from rasa.nlu.tokenizers.tokenizer import Token
  from rasa.nlu.constants import TOKENS_NAMES
  from rasa.core.featurizers.precomputation import MessageContainerForCoreFeaturization
  from rasa.core.featurizers.single_state_featurizer import SingleStateFeaturizer
  from rasa.shared.nlu.training_data.features import Features
  from rasa.shared.nlu.training_data.message import Message
  from rasa.shared.nlu.constants import ACTION_TEXT, ACTION_NAME, ENTITIES, TEXT, INTENT, FEATURE_TYPE_SEQUENCE, FEATURE_TYPE_SENTENCE, ENTITY_ATTRIBUTE_TYPE, ENTITY_ATTRIBUTE_VALUE, ENTITY_ATTRIBUTE_START, ENTITY_ATTRIBUTE_END, ENTITY_TAGS
  from rasa.shared.core.domain import Domain
  from rasa.shared.core.slots import TextSlot
  from rasa.shared.core.constants import ACTION_LISTEN_NAME, ACTIVE_LOOP, PREVIOUS_ACTION, SLOTS, ENTITY_LABEL_SEPARATOR, USER
  from rasa.utils.tensorflow.constants import SENTENCE, SEQUENCE
label_desc: Use image node_id 10 for calling a global function with example usage: test_encode_state__with_lookup__looksup_or_creates_features(action_name) without return types