Update: modify 6 file(s)

Author: vawsgit

docs/docs/Guides/StructuredModel_Export.md

@@ -405,4 +405,4 @@ git commit -m "Add Product model schema v1"
 
 - [StructuredModel Dynamic Creation](StructuredModel_Dynamic_Creation.md) - Import methods
 - [StructuredModel Advanced Functionality](StructuredModel_Advanced_Functionality.md) - Comparison features
-- [JSON Schema Extensions](../../index.md) - Full extension documentation in main README
+- [JSON Schema Extensions](../Getting-Started/README.md) - Full extension documentation

src/stickler/comparators/numeric.py

@@ -2,7 +2,7 @@
 
 import re
 from decimal import Decimal, InvalidOperation
-from typing import Any, Optional, Union
+from typing import Any, Dict, Optional, Union
 
 from stickler.comparators.base import BaseComparator
 
@@ -55,6 +55,16 @@ def __init__(
         else:
             self.absolute_tolerance = absolute_tolerance
 
+    @property
+    def config(self) -> Optional[Dict[str, Any]]:
+        """Return configuration parameters for serialization."""
+        config = {}
+        if self.relative_tolerance != 0.0:
+            config["relative_tolerance"] = self.relative_tolerance
+        if self.absolute_tolerance != 0.0:
+            config["absolute_tolerance"] = self.absolute_tolerance
+        return config or None
+
     def compare(self, str1: Any, str2: Any) -> float:
         """Compare two values numerically.
 

src/stickler/structured_object_evaluator/models/json_schema_field_converter.py

@@ -216,8 +216,9 @@ def _extract_stickler_extensions(
         # Extract comparator
         if "x-aws-stickler-comparator" in property_schema:
             comparator_name = property_schema["x-aws-stickler-comparator"]
+            comparator_config = property_schema.get("x-aws-stickler-comparator-config", {})
             try:
-                extensions["comparator"] = self._create_comparator_from_name(comparator_name)
+                extensions["comparator"] = create_comparator(comparator_name, comparator_config)
             except Exception as e:
                 field_info = f" in field '{field_path}'" if field_path else ""
                 raise ValueError(
@@ -534,6 +535,8 @@ def _build_comparison_extensions(
             Dictionary with comparison extensions in the specified format
         """
         extensions = {}
+        if format not in ("json_schema", "stickler_config"):
+            raise ValueError(f"Unsupported format: {format!r}. Use 'json_schema' or 'stickler_config'.")
         prefix = "x-aws-stickler-" if format == "json_schema" else ""
 
         # Export comparator class name and configuration

src/stickler/structured_object_evaluator/models/structured_model.py

@@ -1194,7 +1194,9 @@ def to_json_schema(cls) -> Dict[str, Any]:
         }
 
         # Add match_threshold if available (check both attribute names for compatibility)
-        threshold = getattr(cls, "match_threshold", None) or getattr(cls, "_match_threshold", None)
+        threshold = getattr(cls, "match_threshold", None)
+        if threshold is None:
+            threshold = getattr(cls, "_match_threshold", None)
         if threshold is not None:
             schema["x-aws-stickler-match-threshold"] = threshold
 
@@ -1207,6 +1209,7 @@ def to_json_schema(cls) -> Dict[str, Any]:
 
             # Validate field has type annotation
             if field_type is None:
+                # Defensive: unreachable through normal Pydantic model construction
                 raise ValueError(f"Field '{field_name}' has no type annotation")
 
             # Unwrap Optional before type checking
@@ -1219,6 +1222,7 @@ def to_json_schema(cls) -> Dict[str, Any]:
                 # Handle List[StructuredModel] or List[primitive]
                 args = get_args(field_type)
                 if not args:
+                    # Defensive: unreachable through normal Pydantic model construction
                     raise ValueError(
                         f"Field '{field_name}' has unparameterized list type. "
                         f"Use List[str], List[int], etc."
@@ -1321,7 +1325,9 @@ def to_stickler_config(cls) -> Dict[str, Any]:
         }
 
         # Add match_threshold if available (check both attribute names for compatibility)
-        threshold = getattr(cls, "match_threshold", None) or getattr(cls, "_match_threshold", None)
+        threshold = getattr(cls, "match_threshold", None)
+        if threshold is None:
+            threshold = getattr(cls, "_match_threshold", None)
         if threshold is not None:
             config["match_threshold"] = threshold
 
@@ -1334,35 +1340,38 @@ def to_stickler_config(cls) -> Dict[str, Any]:
 
             # Validate field has type annotation
             if field_type is None:
+                # Defensive: unreachable through normal Pydantic model construction
                 raise ValueError(f"Field '{field_name}' has no type annotation")
 
             # Unwrap Optional before type checking
             field_type, _ = cls._unwrap_optional(field_type)
 
             # Check if nested StructuredModel - use "structured_model" type
             if cls._is_structured_model_type(field_type):
-                field_config = {
-                    "type": "structured_model",
-                    # Recursively export nested model's fields
-                    "fields": field_type.to_stickler_config()["fields"]
-                }
+                nested_config = field_type.to_stickler_config()
+                field_config = {"type": "structured_model", "fields": nested_config["fields"]}
+                if nested_config.get("model_name"):
+                    field_config["model_name"] = nested_config["model_name"]
+                if nested_config.get("match_threshold") is not None:
+                    field_config["match_threshold"] = nested_config["match_threshold"]
             elif get_origin(field_type) is list:
                 # Handle List[StructuredModel] or List[primitive]
                 args = get_args(field_type)
                 if not args:
+                    # Defensive: unreachable through normal Pydantic model construction
                     raise ValueError(
                         f"Field '{field_name}' has unparameterized list type. "
                         f"Use List[str], List[int], etc."
                     )
                 element_type = args[0]
 
                 if cls._is_structured_model_type(element_type):
-                    # List of StructuredModels - use "list_structured_model" type
-                    field_config = {
-                        "type": "list_structured_model",
-                        # Recursively export element model's fields
-                        "fields": element_type.to_stickler_config()["fields"]
-                    }
+                    nested_config = element_type.to_stickler_config()
+                    field_config = {"type": "list_structured_model", "fields": nested_config["fields"]}
+                    if nested_config.get("model_name"):
+                        field_config["model_name"] = nested_config["model_name"]
+                    if nested_config.get("match_threshold") is not None:
+                        field_config["match_threshold"] = nested_config["match_threshold"]
                 else:
                     # Primitive list - use converter
                     field_config = converter.field_to_stickler_config(field_type, field_info)

tests/structured_object_evaluator/test_export_roundtrip.py

@@ -4,7 +4,7 @@
 preserving their comparison behavior.
 """
 
-from typing import List
+from typing import List, Optional
 
 from stickler.comparators.levenshtein import LevenshteinComparator
 from stickler.comparators.numeric import NumericComparator
@@ -218,3 +218,52 @@ def test_multiple_roundtrips():
     result2 = p2.compare_with(p2)
 
     assert result_orig["overall_score"] == result1["overall_score"] == result2["overall_score"] == 1.0
+
+
+def test_optional_field_roundtrip():
+    """Test round-trip with Optional fields preserves comparison behavior."""
+
+    class OptionalModel(StructuredModel):
+        name: str = ComparableField(threshold=0.8, default=...)
+        note: Optional[str] = ComparableField(threshold=0.6, default=None)
+
+    # JSON Schema round-trip
+    schema = OptionalModel.to_json_schema()
+    Reconstructed = StructuredModel.from_json_schema(schema)
+
+    # Test with non-None values (Optional nature is not preserved in round-trip — known limitation)
+    o1 = OptionalModel(name="Test", note="hello")
+    r1 = Reconstructed(name="Test", note="hello")
+
+    result_orig = o1.compare_with(o1)
+    result_recon = r1.compare_with(r1)
+
+    assert result_orig["overall_score"] == 1.0
+    assert result_recon["overall_score"] == 1.0
+
+
+def test_numeric_comparator_tolerance_roundtrip():
+    """Test that NumericComparator tolerance is preserved after round-trip."""
+
+    class TolerantModel(StructuredModel):
+        value: float = ComparableField(
+            comparator=NumericComparator(absolute_tolerance=0.5),
+            threshold=1.0,
+            default=...
+        )
+
+    # JSON Schema round-trip
+    schema = TolerantModel.to_json_schema()
+    Reconstructed = StructuredModel.from_json_schema(schema)
+    r1 = Reconstructed(value=100.0)
+    r2 = Reconstructed(value=100.3)
+    result = r1.compare_with(r2)
+    assert result["field_scores"]["value"] == 1.0
+
+    # Stickler config round-trip
+    config = TolerantModel.to_stickler_config()
+    Reconstructed2 = StructuredModel.model_from_json(config)
+    r3 = Reconstructed2(value=100.0)
+    r4 = Reconstructed2(value=100.3)
+    result2 = r3.compare_with(r4)
+    assert result2["field_scores"]["value"] == 1.0

tests/structured_object_evaluator/test_model_export.py

@@ -4,7 +4,7 @@
 that export StructuredModel configurations for serialization.
 """
 
-from typing import List
+from typing import List, Optional
 
 from stickler.comparators.levenshtein import LevenshteinComparator
 from stickler.comparators.numeric import NumericComparator
@@ -193,3 +193,58 @@ class DetailedModel(StructuredModel):
     assert field_config["weight"] == 1.5
     assert field_config["clip_under_threshold"] is False
     assert field_config["aggregate"] is True
+
+
+class OptionalFieldModel(StructuredModel):
+    """Model with Optional fields for testing export."""
+    required_name: str = ComparableField(threshold=0.8, default=...)
+    optional_note: Optional[str] = ComparableField(threshold=0.6, default=None)
+    optional_product: Optional[SimpleProduct] = ComparableField(default=None)
+    optional_products: Optional[List[SimpleProduct]] = ComparableField(default=None)
+
+
+def test_to_json_schema_optional_fields():
+    """Test that Optional fields export correctly and are not in required list."""
+    schema = OptionalFieldModel.to_json_schema()
+
+    # Required field is in required list
+    assert "required_name" in schema["required"]
+
+    # Optional fields are NOT in required list
+    assert "optional_note" not in schema["required"]
+    assert "optional_product" not in schema["required"]
+    assert "optional_products" not in schema["required"]
+
+    # Optional[str] unwraps to string type
+    assert schema["properties"]["optional_note"]["type"] == "string"
+
+    # Optional[StructuredModel] unwraps to nested object schema
+    product_prop = schema["properties"]["optional_product"]
+    assert product_prop["type"] == "object"
+    assert "name" in product_prop["properties"]
+    assert "price" in product_prop["properties"]
+
+    # Optional[List[StructuredModel]] unwraps to array with nested items
+    products_prop = schema["properties"]["optional_products"]
+    assert products_prop["type"] == "array"
+    assert products_prop["items"]["type"] == "object"
+    assert "name" in products_prop["items"]["properties"]
+
+
+def test_to_stickler_config_optional_fields():
+    """Test that Optional fields export correctly in Stickler config format."""
+    config = OptionalFieldModel.to_stickler_config()
+
+    # Optional[str] unwraps to str type
+    assert config["fields"]["optional_note"]["type"] == "str"
+
+    # Optional[StructuredModel] unwraps to structured_model type
+    product_field = config["fields"]["optional_product"]
+    assert product_field["type"] == "structured_model"
+    assert "name" in product_field["fields"]
+    assert "price" in product_field["fields"]
+
+    # Optional[List[StructuredModel]] unwraps to list_structured_model type
+    products_field = config["fields"]["optional_products"]
+    assert products_field["type"] == "list_structured_model"
+    assert "name" in products_field["fields"]