Update: modify 3 file(s)

Author: vawsgit

src/stickler/structured_object_evaluator/models/json_schema_field_converter.py

@@ -266,26 +266,6 @@ def _extract_stickler_extensions(
 
         return extensions
 
-    def _create_comparator_from_name(self, comparator_name: str):
-        """Create a comparator instance from its class name.
-        
-        Args:
-            comparator_name: Name of the comparator class
-            
-        Returns:
-            Comparator instance
-            
-        Raises:
-            ValueError: If comparator name is not registered
-        """
-        # Use existing comparator_registry
-        try:
-            return create_comparator(comparator_name, {})
-        except KeyError as e:
-            # The KeyError message from the registry already contains the list of valid comparators
-            # Re-raise as ValueError with the same information
-            raise ValueError(str(e)) from e
-
     def _resolve_ref(self, ref: str) -> Dict[str, Any]:
         """Resolve a $ref reference within the schema.
         
@@ -471,7 +451,7 @@ def field_to_property(self, field_type: Type, field_info: FieldInfo) -> Dict[str
 
         # Extract metadata and build extensions using consolidated helper
         metadata = self._extract_field_metadata(field_info)
-        extensions = self._build_comparison_extensions(metadata, format="json_schema")
+        extensions = self._build_comparison_extensions(metadata, output_format="json_schema")
         property_schema.update(extensions)
 
         # Add Pydantic field params
@@ -502,7 +482,7 @@ def field_to_stickler_config(self, field_type: Type, field_info: FieldInfo) -> D
 
         # Extract metadata and build extensions using consolidated helper
         metadata = self._extract_field_metadata(field_info)
-        extensions = self._build_comparison_extensions(metadata, format="stickler_config")
+        extensions = self._build_comparison_extensions(metadata, output_format="stickler_config")
         field_config.update(extensions)
 
         # Add Pydantic field params
@@ -521,23 +501,23 @@ def field_to_stickler_config(self, field_type: Type, field_info: FieldInfo) -> D
     def _build_comparison_extensions(
         self, 
         metadata: Dict[str, Any], 
-        format: str = "json_schema"
+        output_format: str = "json_schema"
     ) -> Dict[str, Any]:
         """Build comparison extensions in specified format.
         
         Consolidates duplicate logic from field_to_property() and field_to_stickler_config().
         
         Args:
             metadata: Extracted field metadata from _extract_field_metadata()
-            format: Output format - "json_schema" or "stickler_config"
+            output_format: Output format - "json_schema" or "stickler_config"
         
         Returns:
             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 ""
+        if output_format not in ("json_schema", "stickler_config"):
+            raise ValueError(f"Unsupported format: {output_format!r}. Use 'json_schema' or 'stickler_config'.")
+        prefix = "x-aws-stickler-" if output_format == "json_schema" else ""
 
         # Export comparator class name and configuration
         if metadata.get("comparator"):
@@ -546,7 +526,7 @@ def _build_comparison_extensions(
 
             # Export comparator configuration (e.g., tolerance, case_sensitive)
             if hasattr(comparator, "config") and comparator.config:
-                config_key = f"{prefix}comparator-config" if format == "json_schema" else "comparator_config"
+                config_key = f"{prefix}comparator-config" if output_format == "json_schema" else "comparator_config"
                 extensions[config_key] = comparator.config
 
         # Export comparison parameters
@@ -555,7 +535,7 @@ def _build_comparison_extensions(
         if "weight" in metadata:
             extensions[f"{prefix}weight"] = metadata["weight"]
         if metadata.get("clip_under_threshold") is not None:
-            clip_key = f"{prefix}clip-under-threshold" if format == "json_schema" else "clip_under_threshold"
+            clip_key = f"{prefix}clip-under-threshold" if output_format == "json_schema" else "clip_under_threshold"
             extensions[clip_key] = metadata["clip_under_threshold"]
         if metadata.get("aggregate") is not None:
             extensions[f"{prefix}aggregate"] = metadata["aggregate"]

src/stickler/structured_object_evaluator/models/structured_model.py

@@ -1248,7 +1248,7 @@ def to_json_schema(cls) -> Dict[str, Any]:
                     # Extract and add stickler extensions from field metadata
                     metadata = converter._extract_field_metadata(field_info)
                     extensions = converter._build_comparison_extensions(
-                        metadata, format="json_schema"
+                        metadata, output_format="json_schema"
                     )
                     property_schema.update(extensions)
             else:
@@ -1377,10 +1377,11 @@ def to_stickler_config(cls) -> Dict[str, Any]:
                     if nested_config.get("match_threshold") is not None:
                         field_config["match_threshold"] = nested_config["match_threshold"]
                 else:
-                    # Primitive list - use converter
+                    # Primitive list - pass element type, then fix up type string
                     field_config = converter.field_to_stickler_config(
-                        field_type, field_info
+                        element_type, field_info
                     )
+                    field_config["type"] = f"List[{element_type.__name__}]"
             else:
                 # Primitive type - use converter for consistent formatting
                 field_config = converter.field_to_stickler_config(

tests/structured_object_evaluator/test_model_export.py

@@ -40,6 +40,12 @@ class ListModel(StructuredModel):
     products: List[SimpleProduct] = ComparableField()
 
 
+class PrimitiveListModel(StructuredModel):
+    """Model with List[primitive] for testing primitive list export."""
+    tags: List[str] = ComparableField(threshold=0.8)
+    scores: List[int] = ComparableField(threshold=0.9)
+
+
 def test_to_json_schema_basic():
     """Test exporting simple model to JSON Schema format."""
     schema = SimpleProduct.to_json_schema()
@@ -167,6 +173,36 @@ def test_to_stickler_config_list():
     assert "price" in products_field["fields"]
 
 
+def test_to_json_schema_primitive_list():
+    """Test exporting model with List[str] and List[int] to JSON Schema."""
+    schema = PrimitiveListModel.to_json_schema()
+
+    # List[str] should export as array with string items
+    tags_prop = schema["properties"]["tags"]
+    assert tags_prop["type"] == "array"
+    assert tags_prop["items"]["type"] == "string"
+
+    # List[int] should export as array with integer items
+    scores_prop = schema["properties"]["scores"]
+    assert scores_prop["type"] == "array"
+    assert scores_prop["items"]["type"] == "integer"
+
+
+def test_to_stickler_config_primitive_list():
+    """Test exporting model with List[str] and List[int] to Stickler config."""
+    config = PrimitiveListModel.to_stickler_config()
+
+    # List[str] should export with list-aware type, not plain "str"
+    tags_field = config["fields"]["tags"]
+    assert tags_field["type"] == "List[str]"
+    assert tags_field["threshold"] == 0.8
+
+    # List[int] should export with list-aware type, not plain "int"
+    scores_field = config["fields"]["scores"]
+    assert scores_field["type"] == "List[int]"
+    assert scores_field["threshold"] == 0.9
+
+
 def test_export_preserves_metadata():
     """Test that all comparison metadata is preserved in export."""