Add encoder/decoder support for NotApplicableAnalysisCard

Summary:
Add SQA storage support for the new NotApplicableAnalysisCard class:
- encoder.py: Add NotApplicableAnalysisCard check with blob_annotation='not_applicable'
- decoder.py: Add decoding logic for blob_annotation='not_applicable'
- test_sqa_store.py: Add round-trip persistence test

This allows NotApplicableAnalysisCard instances to be saved and loaded
from the database correctly.

Differential Revision: D96248247

Author: shrutipatel31

ax/storage/sqa_store/decoder.py

@@ -23,6 +23,7 @@
     AnalysisCardBase,
     AnalysisCardGroup,
     ErrorAnalysisCard,
+    NotApplicableAnalysisCard,
 )
 from ax.core.arm import Arm
 from ax.core.auxiliary import AuxiliaryExperiment, AuxiliaryExperimentPurpose
@@ -1072,6 +1073,15 @@ def analysis_card_from_sqa(
         blob = none_throws(analysis_card_sqa.blob)
         blob_annotation = analysis_card_sqa.blob_annotation
 
+        if blob_annotation == "not_applicable":
+            return NotApplicableAnalysisCard(
+                name=analysis_card_sqa.name,
+                title=title,
+                subtitle=subtitle,
+                df=read_json(StringIO(analysis_card_sqa.dataframe_json)),
+                blob=blob,
+                timestamp=analysis_card_sqa.timestamp,
+            )
         if blob_annotation == "error":
             return ErrorAnalysisCard(
                 name=analysis_card_sqa.name,

ax/storage/sqa_store/encoder.py

@@ -19,6 +19,7 @@
     AnalysisCardBase,
     AnalysisCardGroup,
     ErrorAnalysisCard,
+    NotApplicableAnalysisCard,
 )
 from ax.core.arm import Arm
 from ax.core.auxiliary import AuxiliaryExperiment, AuxiliaryExperimentPurpose
@@ -1163,7 +1164,9 @@ def analysis_card_to_sqa(
 
         card = assert_is_instance(analysis_card, AnalysisCard)
 
-        if isinstance(card, ErrorAnalysisCard):
+        if isinstance(card, NotApplicableAnalysisCard):
+            blob_annotation = "not_applicable"
+        elif isinstance(card, ErrorAnalysisCard):
             blob_annotation = "error"
         elif isinstance(card, PlotlyAnalysisCard):
             blob_annotation = "plotly"

ax/storage/sqa_store/sqa_config.py

@@ -11,7 +11,7 @@
 from enum import Enum
 from typing import Any, cast
 
-from ax.analysis.analysis import AnalysisCard
+from ax.core.analysis_card import AnalysisCard
 from ax.core.arm import Arm
 from ax.core.auxiliary import AuxiliaryExperiment, AuxiliaryExperimentPurpose
 from ax.core.batch_trial import AbandonedArm

ax/storage/sqa_store/tests/test_sqa_store.py

@@ -24,7 +24,11 @@
     choose_generation_strategy,
     GenerationStrategyDispatchStruct,
 )
-from ax.core.analysis_card import AnalysisCard, AnalysisCardGroup
+from ax.core.analysis_card import (
+    AnalysisCard,
+    AnalysisCardGroup,
+    NotApplicableAnalysisCard,
+)
 from ax.core.arm import Arm
 from ax.core.auxiliary import (
     AuxiliaryExperiment,
@@ -3067,6 +3071,45 @@ def test_analysis_card(self) -> None:
             self.assertEqual(loaded_small_group_plotly.name, plotly_analysis_card.name)
             self.assertEqual(loaded_small_group_plotly.blob, plotly_analysis_card.blob)
 
+    def test_not_applicable_analysis_card(self) -> None:
+        """Test that NotApplicableAnalysisCard persists through SQA round-trip."""
+        test_df = pd.DataFrame(
+            columns=["a", "b"],
+            data=[
+                [1, 2],
+                [3, 4],
+            ],
+        )
+
+        not_applicable_card = NotApplicableAnalysisCard(
+            name="test_not_applicable_analysis_card",
+            title="TestAnalysis -- Not Available Yet",
+            subtitle="Experiment has no data.",
+            df=test_df,
+            blob="Waiting for experiment data.",
+        )
+
+        save_experiment(self.experiment)
+
+        save_analysis_card(
+            not_applicable_card,
+            self.experiment,
+        )
+
+        loaded_analysis_cards = load_analysis_cards_by_experiment_name(
+            self.experiment.name
+        )
+
+        self.assertEqual(len(loaded_analysis_cards), 1)
+        loaded_card = assert_is_instance(
+            loaded_analysis_cards[0], NotApplicableAnalysisCard
+        )
+        self.assertEqual(loaded_card.name, not_applicable_card.name)
+        self.assertEqual(loaded_card.title, not_applicable_card.title)
+        self.assertEqual(loaded_card.subtitle, not_applicable_card.subtitle)
+        self.assertEqual(loaded_card.blob, not_applicable_card.blob)
+        self.assertTrue(loaded_card.df.equals(not_applicable_card.df))
+
     def test_delete_generation_strategy(self) -> None:
         # GIVEN an experiment with a generation strategy
         experiment = get_branin_experiment()