Fix formatter to handle dict keys with special characters (#2891)

* Fix formatter to handle dict keys with special characters

* add test for keys with periods

Author: daniel-trinh

.generator/src/generator/formatter.py

@@ -390,6 +390,13 @@ def format_data_with_schema_list(
     return parameters, imports
 
 
+def _is_valid_identifier(key):
+    """Check if a key can be used as a Python keyword argument."""
+    if not key or not key[0].isalpha() and key[0] != '_':
+        return False
+    return all(c.isalnum() or c == '_' for c in key)
+
+
 @format_data_with_schema.register(dict)
 def format_data_with_schema_dict(
     data,
@@ -402,6 +409,7 @@ def format_data_with_schema_dict(
     """Format data with schema."""
     assert version is not None
     name, imports = get_name_and_imports(schema, version, imports)
+    use_dict_literal = False
 
     parameters = ""
     if "properties" in schema:
@@ -436,7 +444,13 @@ def format_data_with_schema_dict(
                 replace_values=replace_values,
                 version=version,
             )
-            parameters += f"{escape_reserved_keyword(k)}={value}, "
+            safe_key = escape_reserved_keyword(k)
+            if not _is_valid_identifier(safe_key):
+                # Key contains special characters (like dots), must use dict literal
+                use_dict_literal = True
+                parameters += f'"{k}": {value}, '
+            else:
+                parameters += f"{safe_key}={value}, "
             imports = _merge_imports(imports, extra_imports)
 
     if "oneOf" in schema:
@@ -458,6 +472,9 @@ def format_data_with_schema_dict(
         parameters = f"[{key_val_pairs}]"
 
     if name:
+        # If we detected invalid identifiers, use dict literal syntax
+        if use_dict_literal:
+            return f"{{{parameters}}}", imports
         return f"{name}({parameters})", imports
 
     return parameters, imports

.generator/tests/test_formatter.py

@@ -0,0 +1,93 @@
+import pytest
+from collections import defaultdict
+from generator.formatter import _is_valid_identifier, format_data_with_schema
+
+
+class TestIsValidIdentifier:
+    @pytest.mark.parametrize("key,expected", [
+        ("valid_key", True),
+        ("_valid_key", True),
+        ("ValidKey123", True),
+        ("key123", True),
+        ("key.with.dots", False),
+        ("123invalid", False),
+        (".starts_with_dot", False),
+        ("", False),
+        ("key-with-dash", False),
+        ("key with space", False),
+        ("key@special", False),
+    ])
+    def test_is_valid_identifier(self, key, expected):
+        assert _is_valid_identifier(key) == expected
+
+
+class TestFormatDataWithSchemaDictWithSpecialChars:
+    def test_ocsf_dotted_keys_actual_failing_case(self):
+        data = {
+            "ocsf.activity_name": "Other",
+            "ocsf.activity_id": "99"
+        }
+        schema = {
+            "additionalProperties": {
+                "type": "string"
+            }
+        }
+
+        result, imports = format_data_with_schema(
+            data,
+            schema,
+            version="v1"
+        )
+
+        assert result.startswith("{")
+        assert result.endswith("}")
+        assert '"ocsf.activity_name": \'Other\'' in result
+        assert '"ocsf.activity_id": \'99\'' in result
+        assert "dict(" not in result
+
+    def test_multiple_dotted_keys(self):
+        data = {
+            "ocsf.activity_name": "Other",
+            "ocsf.activity_id": "99",
+            "ocsf.category_name": "System Activity"
+        }
+        schema = {
+            "additionalProperties": {
+                "type": "string"
+            }
+        }
+
+        result, imports = format_data_with_schema(
+            data,
+            schema,
+            version="v1"
+        )
+
+        assert result.startswith("{")
+        assert result.endswith("}")
+        assert '"ocsf.activity_name": \'Other\'' in result
+        assert '"ocsf.activity_id": \'99\'' in result
+        assert '"ocsf.category_name": \'System Activity\'' in result
+        assert "dict(" not in result
+
+    def test_dict_with_valid_identifiers_uses_constructor(self):
+        data = {
+            "normal_key": "value1",
+            "another_key": "value2"
+        }
+        schema = {
+            "additionalProperties": {
+                "type": "string"
+            }
+        }
+
+        result, imports = format_data_with_schema(
+            data,
+            schema,
+            version="v1"
+        )
+
+        assert result.startswith("dict(")
+        assert result.endswith(")")
+        assert "normal_key='value1'" in result
+        assert "another_key='value2'" in result