lint, address review comment

Author: jackyzha0

src/replit_river/codegen/client.py

@@ -575,11 +575,11 @@ def extract_props(tpe: RiverType) -> list[dict[str, RiverType]]:
                         if name == "$kind":
                             safe_name = "kind"
                         else:
-                            # For TypedDict encoder, use normalized name to access the TypedDict field
-                            # but the output dictionary key should use the original name
+                            # For TypedDict encoder, use normalized name to access
+                            # the TypedDict field but the output dictionary key should
+                            # use the original name
                             if base_model == "TypedDict":
-                                specialized_name = normalize_special_chars(name)
-                                safe_name = specialized_name.lstrip("_") if name != specialized_name else name
+                                safe_name = normalize_special_chars(name)
                             else:
                                 safe_name = name
                         if prop.type == "object" and not prop.patternProperties:
@@ -683,15 +683,17 @@ def extract_props(tpe: RiverType) -> list[dict[str, RiverType]]:
                     if name != specialized_name:
                         if base_model == "BaseModel":
                             # Pydantic doesn't allow leading underscores in field names
-                            effective_name = specialized_name.lstrip("_")
+                            effective_name = specialized_name
                             extras.append(f"alias={repr(name)}")
                         elif base_model == "TypedDict":
                             # For TypedDict, we use the normalized name directly
-                            # TypedDict doesn't support aliases, so we normalize the field name
-                            effective_name = specialized_name.lstrip("_")
+                            # TypedDict doesn't support aliases, so we normalize
+                            # the field name
+                            effective_name = specialized_name
                         else:
-                            # For RiverError (which extends BaseModel), use alias like BaseModel
-                            effective_name = specialized_name.lstrip("_")
+                            # For RiverError (which extends BaseModel), use alias
+                            # like BaseModel
+                            effective_name = specialized_name
                             extras.append(f"alias={repr(name)}")
 
                     effective_field_names[effective_name].append(name)

src/replit_river/codegen/typing.py

@@ -165,7 +165,7 @@ def work(
 def normalize_special_chars(value: str) -> str:
     for char in SPECIAL_CHARS:
         value = value.replace(char, "_")
-    return value
+    return value.lstrip("_")
 
 
 def render_type_expr(value: TypeExpression) -> str:

tests/v1/codegen/test_input_special_chars.py

@@ -6,11 +6,12 @@
 
 
 def test_input_special_chars_basemodel() -> None:
-    """Test that codegen handles special characters in input field names for BaseModel."""
-    
-    # Test should pass without raising an exception
+    """Handles special characters in input field names for BaseModel."""
+
     schema_to_river_client_codegen(
-        read_schema=lambda: open("tests/v1/codegen/rpc/input-special-chars-schema.json"),
+        read_schema=lambda: open(
+            "tests/v1/codegen/rpc/input-special-chars-schema.json"
+        ),  # noqa: E501
         target_path="tests/v1/codegen/rpc/generated_input_special",
         client_name="InputSpecialClient",
         typed_dict_inputs=False,  # BaseModel inputs
@@ -21,11 +22,13 @@ def test_input_special_chars_basemodel() -> None:
 
 
 def test_input_special_chars_typeddict() -> None:
-    """Test that codegen handles special characters in input field names for TypedDict."""
-    
+    """Handles special characters in input field names for TypedDict."""
+
     # Test should pass without raising an exception
     schema_to_river_client_codegen(
-        read_schema=lambda: open("tests/v1/codegen/rpc/input-special-chars-schema.json"),
+        read_schema=lambda: open(
+            "tests/v1/codegen/rpc/input-special-chars-schema.json"
+        ),  # noqa: E501
         target_path="tests/v1/codegen/rpc/generated_input_special_td",
         client_name="InputSpecialTDClient",
         typed_dict_inputs=True,  # TypedDict inputs
@@ -36,11 +39,13 @@ def test_input_special_chars_typeddict() -> None:
 
 
 def test_input_collision_error_basemodel() -> None:
-    """Test that codegen raises ValueError for input field name collisions with BaseModel."""
+    """Raises ValueError for input field name collisions with BaseModel."""
 
     with pytest.raises(ValueError) as exc_info:
         schema_to_river_client_codegen(
-            read_schema=lambda: open("tests/v1/codegen/rpc/input-collision-schema.json"),
+            read_schema=lambda: open(
+                "tests/v1/codegen/rpc/input-collision-schema.json"
+            ),  # noqa: E501
             target_path="tests/v1/codegen/rpc/generated_input_collision",
             client_name="InputCollisionClient",
             typed_dict_inputs=False,  # BaseModel inputs
@@ -58,11 +63,13 @@ def test_input_collision_error_basemodel() -> None:
 
 
 def test_input_collision_error_typeddict() -> None:
-    """Test that codegen raises ValueError for input field name collisions with TypedDict."""
+    """Raises ValueError for input field name collisions with TypedDict."""
 
     with pytest.raises(ValueError) as exc_info:
         schema_to_river_client_codegen(
-            read_schema=lambda: open("tests/v1/codegen/rpc/input-collision-schema.json"),
+            read_schema=lambda: open(
+                "tests/v1/codegen/rpc/input-collision-schema.json"
+            ),  # noqa: E501
             target_path="tests/v1/codegen/rpc/generated_input_collision_td",
             client_name="InputCollisionTDClient",
             typed_dict_inputs=True,  # TypedDict inputs
@@ -80,8 +87,8 @@ def test_input_collision_error_typeddict() -> None:
 
 
 def test_init_special_chars_basemodel() -> None:
-    """Test that codegen handles special characters in init field names for BaseModel."""
-    
+    """Handles special characters in init field names for BaseModel."""
+
     init_schema = {
         "services": {
             "test_service": {
@@ -92,21 +99,21 @@ def test_init_special_chars_basemodel() -> None:
                             "properties": {
                                 "init-field1": {"type": "string"},
                                 "init:field2": {"type": "number"},
-                                "init.field3": {"type": "boolean"}
+                                "init.field3": {"type": "boolean"},
                             },
-                            "required": ["init-field1"]
+                            "required": ["init-field1"],
                         },
                         "output": {"type": "boolean"},
                         "errors": {"not": {}},
-                        "type": "stream"
+                        "type": "stream",
                     }
                 }
             }
         }
     }
-    
+
     import json
-    
+
     # Test should pass without raising an exception
     schema_to_river_client_codegen(
         read_schema=lambda: StringIO(json.dumps(init_schema)),
@@ -120,8 +127,8 @@ def test_init_special_chars_basemodel() -> None:
 
 
 def test_init_special_chars_typeddict() -> None:
-    """Test that codegen handles special characters in init field names for TypedDict."""
-    
+    """Handles special characters in init field names for TypedDict."""
+
     init_schema = {
         "services": {
             "test_service": {
@@ -132,21 +139,21 @@ def test_init_special_chars_typeddict() -> None:
                             "properties": {
                                 "init-field1": {"type": "string"},
                                 "init:field2": {"type": "number"},
-                                "init.field3": {"type": "boolean"}
+                                "init.field3": {"type": "boolean"},
                             },
-                            "required": ["init-field1"]
+                            "required": ["init-field1"],
                         },
                         "output": {"type": "boolean"},
                         "errors": {"not": {}},
-                        "type": "stream"
+                        "type": "stream",
                     }
                 }
             }
         }
     }
-    
+
     import json
-    
+
     # Test should pass without raising an exception
     schema_to_river_client_codegen(
         read_schema=lambda: StringIO(json.dumps(init_schema)),