Address PR review: refactor unknown event handling

Author: Alan4506

codegen/core/src/main/java/software/amazon/smithy/python/codegen/generators/UnionGenerator.java

@@ -144,8 +144,6 @@ private void generateDeserializer() {
         writer.addImport("smithy_core.deserializers", "ShapeDeserializer");
         writer.addImport("smithy_core.exceptions", "SerializationError");
 
-        // TODO: add in unknown handling
-
         var symbol = symbolProvider.toSymbol(shape);
         var deserializerSymbol = symbol.expectProperty(SymbolProperties.DESERIALIZER);
         var schemaSymbol = symbol.expectProperty(SymbolProperties.SCHEMA);
@@ -169,7 +167,7 @@ def _consumer(self, schema: Schema, de: ShapeDeserializer) -> None:
                             ${4C|}
                             case _:
                                 logger.debug("Unexpected member schema: %s", schema)
-                                self._set_result($5L(tag=schema.member_name or ""))
+                                self._set_result($5L(tag=schema.expect_member_name()))
 
                     def _set_result(self, value: $2T) -> None:
                         if self._result is not None:

packages/smithy-aws-event-stream/src/smithy_aws_event_stream/_private/deserializers.py

@@ -10,7 +10,7 @@
     SpecificShapeDeserializer,
 )
 from smithy_core.schemas import Schema
-from smithy_core.shapes import ShapeID, ShapeType
+from smithy_core.shapes import ShapeType
 from smithy_core.traits import EventHeaderTrait
 from smithy_core.utils import expect_type
 
@@ -50,34 +50,11 @@ def read_struct(
                     message_deserializer = self._create_deserializer(schema, headers)
                     message_deserializer.read_struct(schema, consumer)
                 else:
-                    member_schema = schema.members.get(member_name)
-                    if member_schema is None:
-                        # Unknown event type. Call the consumer with a
-                        # schema that carries the event type name as
-                        # member_name and a member_index of -1 so the
-                        # generated default branch constructs the unknown
-                        # variant with the correct tag.
-                        logger.debug("Unknown event type: %s", member_name)
-
-                        _UNKNOWN_TARGET = Schema(
-                            id=ShapeID("smithy.unknown#Unknown"),
-                            shape_type=ShapeType.STRUCTURE,
-                        )
-                        unknown_schema = Schema(
-                            id=ShapeID(f"smithy.unknown#Unknown${member_name}"),
-                            shape_type=ShapeType.STRUCTURE,
-                            member_target=_UNKNOWN_TARGET,
-                            member_index=-1,
-                        )
-                        consumer(
-                            unknown_schema,
-                            self._payload_codec.create_deserializer(b"{}"),
-                        )
-                    else:
-                        message_deserializer = self._create_deserializer(
-                            member_schema, headers
-                        )
-                        consumer(member_schema, message_deserializer)
+                    member_schema = self._resolve_member_schema(schema, member_name)
+                    message_deserializer = self._create_deserializer(
+                        member_schema, headers
+                    )
+                    consumer(member_schema, message_deserializer)
             case "exception":
                 member_name = expect_type(str, headers[":exception-type"])
                 member_schema = schema.members[member_name]
@@ -94,6 +71,21 @@ def read_struct(
             case _:
                 raise EventError(f"Unknown event structure: {self._event}")
 
+    def _resolve_member_schema(self, schema: Schema, member_name: str) -> Schema:
+        if member_schema := schema.members.get(member_name):
+            return member_schema
+
+        logger.debug(
+            "Received unmodeled event stream member %s for union %s",
+            member_name,
+            schema.id,
+        )
+        return Schema.member(
+            id=schema.id.with_member(member_name),
+            target=schema,
+            index=-1,
+        )
+
     def _create_deserializer(
         self, schema: Schema, headers: HEADERS_DICT
     ) -> ShapeDeserializer:

packages/smithy-aws-event-stream/tests/unit/_private/__init__.py

@@ -429,7 +429,7 @@ def _consumer(self, schema: Schema, de: ShapeDeserializer) -> None:
                 self._set_result(EventStreamErrorEvent(ErrorEvent.deserialize(de)))
 
             case _:
-                self._set_result(EventStreamUnknown(tag=schema.member_name or ""))
+                self._set_result(EventStreamUnknown(tag=schema.expect_member_name()))
 
     def _set_result(self, value: EventStream) -> None:
         if self._result is not None:
@@ -636,11 +636,11 @@ def _consumer(schema: Schema, de: ShapeDeserializer) -> None:
 
 
 UNKNOWN_EVENT_CASE = (
-    EventStreamUnknown(tag="intermediateGroupEvent"),
+    EventStreamUnknown(tag="unmodeledEvent"),
     EventMessage(
         headers={
             ":message-type": "event",
-            ":event-type": "intermediateGroupEvent",
+            ":event-type": "unmodeledEvent",
             ":content-type": "application/json",
         },
         payload=b"{}",

packages/smithy-aws-event-stream/tests/unit/_private/test_deserializers.py

@@ -133,7 +133,7 @@ def test_deserialize_unknown_event_type():
     message = EventMessage(
         headers={
             ":message-type": "event",
-            ":event-type": "intermediateGroupEvent",
+            ":event-type": "unmodeledEvent",
             ":content-type": "application/json",
         },
         payload=b"{}",
@@ -143,4 +143,4 @@ def test_deserialize_unknown_event_type():
     deserializer = EventDeserializer(event=source, payload_codec=JSONCodec())
     result = EventStreamDeserializer().deserialize(deserializer)
     assert isinstance(result, EventStreamUnknown)
-    assert result.tag == "intermediateGroupEvent"
+    assert result.tag == "unmodeledEvent"