Generalize Nullable model to support arbitrary context keys

The Nullable model previously hardcoded three healthcare LOBs (MD, MP, ME).
Now uses Pydantic's extra="allow" to accept any context keys, making
tablespec usable across domains (regional, environmental, etc.) while
maintaining full backward compatibility with existing YAML files.

Model changes:
- Nullable uses ConfigDict(extra="allow") instead of fixed fields
- is_nullable_for_all_contexts() iterates dynamic fields via model_dump()
- JSON schema updated to use additionalProperties instead of fixed props

Consumer updates:
- Renamed lob/lobs variables to context/contexts across prompts, GX
  baseline, generators, validators
- Updated docstrings from "LOB-aware" to "context-aware"
- Excel converter keeps MD/MP/ME as default presentation columns

Tests:
- 4 new tests for custom contexts, mixed contexts, model_dump behavior
- All 1889 tests passing

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: easel

src/tablespec/excel_converter.py

@@ -11,7 +11,6 @@
 import contextlib
 import json
 import logging
-import re
 from pathlib import Path
 from typing import Any, ClassVar
 
@@ -77,7 +76,10 @@ class ExcelConstants:
     # Table type options
     TABLE_TYPES: ClassVar[list[str]] = ["provided", "generated", "lookup"]
 
-    # LOB options
+    # Default nullable context keys for Excel column headers.
+    # These represent the default healthcare contexts (Medicaid/Marketplace/Medicare).
+    # The Excel format uses a fixed set of columns, so these serve as the default
+    # presentation layer even though the underlying Nullable model accepts arbitrary keys.
     LOBS: ClassVar[list[str]] = ["MD", "MP", "ME"]
 
     # Domain types

src/tablespec/gx_baseline.py

@@ -249,17 +249,17 @@ def generate_baseline_column_expectations(
         # 3. Nullability (from UMF nullable field, not profiling)
         nullable = column.get("nullable", {})
         if nullable:
-            # Check if required for any LOB
-            required_lobs = [lob for lob, is_null in nullable.items() if not is_null]
-            if required_lobs:
+            # Check if required for any context
+            required_contexts = [ctx for ctx, is_null in nullable.items() if not is_null]
+            if required_contexts:
                 expectations.append(
                     {
                         "type": "expect_column_values_to_not_be_null",
                         "kwargs": {"column": column_name},
                         "meta": {
-                            "description": f"Column {column_name} is required (nullable=false) for LOBs: {', '.join(required_lobs)}",
+                            "description": f"Column {column_name} is required (nullable=false) for contexts: {', '.join(required_contexts)}",
                             "severity": "critical",
-                            "lob": required_lobs,
+                            "contexts": required_contexts,
                             "generated_from": "baseline",
                         },
                     }

src/tablespec/models/umf.py

@@ -200,11 +200,19 @@ def normalize_filename_pattern(cls, data: Any) -> Any:
 
 
 class Nullable(BaseModel):
-    """Nullable configuration per Line of Business."""
+    """Nullable configuration per context (e.g., Line of Business).
 
-    MD: bool | None = Field(default=None, description="Nullable for Medicaid")
-    MP: bool | None = Field(default=None, description="Nullable for Medicare Part D")
-    ME: bool | None = Field(default=None, description="Nullable for Medicare")
+    Accepts arbitrary context keys with boolean values. Common healthcare
+    contexts include MD (Medicaid), MP (Medicare Part D), ME (Medicare),
+    but any domain-specific keys are supported.
+
+    Examples:
+        Nullable(MD=False, MP=False, ME=False)      # Healthcare LOBs
+        Nullable(US=False, EU=True)                  # Regional contexts
+        Nullable(production=False, staging=True)      # Environment contexts
+    """
+
+    model_config = ConfigDict(extra="allow")
 
 
 class JoinViaSpec(BaseModel):
@@ -565,9 +573,9 @@ def precision_recommended_for_decimal(cls, v, info) -> int | None:
         return v
 
     def is_nullable_for_all_contexts(self) -> bool:
-        """Check if column is nullable across all LOB contexts.
+        """Check if column is nullable across all contexts.
 
-        Returns True if nullable for all contexts or if nullable is True.
+        Returns True if nullable for all contexts or if nullable is not specified.
         Returns False if required (non-nullable) for any context.
         """
         if self.nullable is None:
@@ -576,17 +584,14 @@ def is_nullable_for_all_contexts(self) -> bool:
             return self.nullable
         if isinstance(self.nullable, dict):
             return all(self.nullable.values())
-        # If it's a Nullable model instance
-        return all(
-            [
-                getattr(self.nullable, "MD", True),
-                getattr(self.nullable, "MP", True),
-                getattr(self.nullable, "ME", True),
-            ]
-        )
+        # Nullable model instance — iterate all set fields (extra fields included)
+        fields = self.nullable.model_dump(exclude_none=True)
+        if not fields:
+            return True  # No contexts defined = nullable by default
+        return all(fields.values())
 
     def is_required_for_any_context(self) -> bool:
-        """Check if column is required (non-nullable) for any LOB context.
+        """Check if column is required (non-nullable) for any context.
 
         Returns True if required for at least one context.
         Returns False if nullable for all contexts.

src/tablespec/prompts/column_validation.py

@@ -4,13 +4,13 @@
 from typing import Any
 
 from tablespec.gx_baseline import BaselineExpectationGenerator
-
-logger = logging.getLogger(__name__)
 from tablespec.prompts.expectation_guide import (
     format_quick_reference,
     get_pending_decision_tree,
 )
 
+logger = logging.getLogger(__name__)
+
 
 def should_generate_column_prompt(col: dict[str, Any]) -> bool:
     """Check if column needs a dedicated validation prompt.
@@ -185,8 +185,8 @@ def generate_column_validation_prompt(
         exp.get("meta", {}).get("generated_from") == "domain_type" for exp in baseline_expectations
     )
 
-    # Required LOBs
-    req_lobs = [lob for lob, is_null in sorted(nullable.items()) if not is_null]
+    # Required contexts (e.g. LOBs like MD/ME/MP, or any configurable keys)
+    req_contexts = [ctx for ctx, is_null in sorted(nullable.items()) if not is_null]
 
     # Build domain type hint section
     domain_type_section = ""
@@ -274,8 +274,8 @@ def generate_column_validation_prompt(
 **{col_name}** ({data_type}): {col_desc}
 """
 
-    if req_lobs:
-        prompt += f"- **Required for LOBs**: {', '.join(req_lobs)}\n"
+    if req_contexts:
+        prompt += f"- **Required for contexts**: {', '.join(req_contexts)}\n"
     if format_spec:
         prompt += f"- **Format**: {format_spec}\n"
     if max_length:

src/tablespec/prompts/survivorship.py

@@ -675,7 +675,7 @@ def generate_survivorship_prompt_per_column(
     # Build nullable section
     nullable_section = ""
     if nullable:
-        nullable_parts = [f"{lob}: {str(val).lower()}" for lob, val in sorted(nullable.items())]
+        nullable_parts = [f"{ctx}: {str(val).lower()}" for ctx, val in sorted(nullable.items())]
         if nullable_parts:
             nullable_section = f"\n- **Nullable**: {', '.join(nullable_parts)}"
 

src/tablespec/prompts/validation.py

@@ -337,10 +337,10 @@ def generate_validation_prompt(umf_data: dict[str, Any]) -> str:
         # Build compact single-line format: **COL** (TYPE): Desc. [Req: LOBs.] [Fmt: X.] [Ex: a,b.] [Note: X.]
         line = f"**{col_name}** ({data_type}): {col_desc}."
 
-        # Add required LOBs (only non-nullable)
-        req_lobs = [lob for lob, is_null in sorted(nullable.items()) if not is_null]
-        if req_lobs:
-            line += f" Req: {'/'.join(req_lobs)}."
+        # Add required contexts (only non-nullable)
+        req_contexts = [ctx for ctx, is_null in sorted(nullable.items()) if not is_null]
+        if req_contexts:
+            line += f" Req: {'/'.join(req_contexts)}."
 
         # Add format
         if format_spec:

src/tablespec/prompts/validation_per_column.py

@@ -77,14 +77,14 @@ def _generate_column_validation_prompt_focused(
     format_spec = column_data.get("format", "")
     domain_type = column_data.get("domain_type")
 
-    # Required LOBs
-    req_lobs = [lob for lob, is_null in sorted(nullable.items()) if not is_null]
+    # Required contexts (e.g. LOBs like MD/ME/MP, or any configurable keys)
+    req_contexts = [ctx for ctx, is_null in sorted(nullable.items()) if not is_null]
 
     # Build auto-generated validations list
     auto_validations = [
         "- Column existence check",
         f"- Data type validation ({data_type})",
-        f"- Nullability constraints (required for: {', '.join(req_lobs) if req_lobs else 'none'})",
+        f"- Nullability constraints (required for: {', '.join(req_contexts) if req_contexts else 'none'})",
     ]
     if max_length:
         auto_validations.append(f"- Max length constraint ({max_length} characters)")
@@ -106,7 +106,7 @@ def _generate_column_validation_prompt_focused(
 - **Column**: {column_name}
 - **Type**: {data_type}
 - **Max Length**: {max_length or "N/A"}
-- **Required LOBs**: {", ".join(req_lobs) if req_lobs else "None"}
+- **Required Contexts**: {", ".join(req_contexts) if req_contexts else "None"}
 - **Description**: {col_desc}
 {f"- **Format**: {format_spec}" if format_spec else ""}
 

src/tablespec/schemas/generators.py

@@ -23,10 +23,10 @@ class JSONSchema(TypedDict, total=False):
 
 
 def _resolve_nullable(nullable_value: Any) -> bool:
-    """Resolve nullable value from bool, dict (LOB-specific), or None.
+    """Resolve nullable value from bool, dict (context-specific), or None.
 
-    Handles both simple boolean nullable flags and LOB-specific nullable dicts
-    (e.g., {"MD": True, "MP": False, "ME": True} for Medicaid/Medicare).
+    Handles both simple boolean nullable flags and context-specific nullable dicts
+    (e.g., {"MD": True, "MP": False, "ME": True} or any arbitrary context keys).
 
     Returns True (nullable) by default when value is missing or unrecognized.
     """

src/tablespec/schemas/umf.schema.json

@@ -741,50 +741,12 @@
       "type": "object"
     },
     "Nullable": {
-      "description": "Nullable configuration per Line of Business.",
-      "properties": {
-        "MD": {
-          "anyOf": [
-            {
-              "type": "boolean"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "description": "Nullable for Medicaid",
-          "title": "Md"
-        },
-        "MP": {
-          "anyOf": [
-            {
-              "type": "boolean"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "description": "Nullable for Medicare Part D",
-          "title": "Mp"
-        },
-        "ME": {
-          "anyOf": [
-            {
-              "type": "boolean"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "description": "Nullable for Medicare",
-          "title": "Me"
-        }
+      "description": "Nullable configuration per context. Keys are context identifiers (e.g., MD, MP, ME for healthcare LOBs), values are booleans indicating whether the column is nullable in that context.",
+      "type": "object",
+      "additionalProperties": {
+        "type": "boolean"
       },
-      "title": "Nullable",
-      "type": "object"
+      "title": "Nullable"
     },
     "OutgoingRelationship": {
       "description": "Outgoing foreign key relationship to another table.",

src/tablespec/spark_factory.py

@@ -14,7 +14,7 @@
 import os
 from pathlib import Path
 import sys
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 import warnings
 
 # Disable tqdm progress bars and suppress warnings BEFORE importing PySpark