Interpret strings with respect to schema when conforming properties

Author: ReubenFrankel

singer_sdk/helpers/_typing.py

@@ -5,6 +5,7 @@
 import copy
 import datetime
 import decimal
+import json
 import logging
 import math
 import typing as t
@@ -518,7 +519,7 @@ def _conform_uniform_list(
     return output, unmapped_properties
 
 
-def _conform_primitive_property(  # noqa: PLR0911
+def _conform_primitive_property(  # noqa: PLR0911, C901
     elem: t.Any,  # noqa: ANN401
     property_schema: dict,
 ) -> t.Any:  # noqa: ANN401
@@ -542,6 +543,26 @@ def _conform_primitive_property(  # noqa: PLR0911
         if math.isnan(elem) or math.isinf(elem):
             return None
         return elem
+    if isinstance(elem, str) and not is_string_type(property_schema):
+        return _interpret_string_property(elem, property_schema)
     if _is_exclusive_boolean_type(property_schema):
         return None if elem is None else elem != 0
     return elem
+
+
+def _interpret_string_property(
+    elem: str,
+    property_schema: dict,
+) -> t.Any:  # noqa: ANN401
+    if not elem:
+        return None
+    if is_boolean_type(property_schema):
+        return elem.lower() == "true"
+    if is_integer_type(property_schema):
+        return int(elem)
+    if is_number_type(property_schema):
+        d = decimal.Decimal(elem)
+        return None if math.isnan(d) or math.isinf(d) else d
+    if is_array_type(property_schema) or is_object_type(property_schema):
+        return json.loads(elem)
+    return elem

tests/core/test_typing.py

@@ -353,6 +353,39 @@ def test_conform_object_additional_properties():
         pytest.param(
             decimal.Decimal("nan"), {"type": "number"}, None, id="decimal_nan_to_number"
         ),
+        pytest.param("", {"type": "string"}, "", id="string_empty_to_string"),
+        pytest.param(
+            "", {"type": "boolean"}, None, id="string_empty_to_any_non_string"
+        ),
+        pytest.param("true", {"type": "boolean"}, True, id="string_true_to_boolean"),
+        pytest.param(
+            "TRUE", {"type": "boolean"}, True, id="string_true_uppercase_to_boolean"
+        ),
+        pytest.param("false", {"type": "boolean"}, False, id="string_false_to_boolean"),
+        pytest.param(
+            "something else",
+            {"type": "boolean"},
+            False,
+            id="string_not_true_to_boolean",
+        ),
+        pytest.param("3", {"type": "integer"}, 3, id="string_integer_to_integer"),
+        pytest.param(
+            "3.14",
+            {"type": "number"},
+            decimal.Decimal("3.14"),
+            id="string_float_to_number",
+        ),
+        pytest.param("inf", {"type": "number"}, None, id="string_inf_to_number"),
+        pytest.param("nan", {"type": "number"}, None, id="string_nan_to_number"),
+        pytest.param(
+            "[1, 2, 3]", {"type": "array"}, [1, 2, 3], id="string_json_array_to_array"
+        ),
+        pytest.param(
+            '{"a": 1, "b": true, "c": 3.14}',
+            {"type": "object"},
+            {"a": 1, "b": True, "c": 3.14},
+            id="string_json_object_to_object",
+        ),
     ],
 )
 def test_conform_primitives(value: t.Any, type_dict: dict, expected: t.Any):