smithy-xml 0.2.0__tar.gz → 0.3.0__tar.gz

smithy_xml-0.3.0/.changes/0.3.0.json

@@ -0,0 +1,16 @@
+{
+  "changes": [
+    {
+      "type": "breaking",
+      "description": "Declared explicit `__all__` exports on all public modules. Names that were previously importable only incidentally (via `from module import *` or as un-annotated module attributes) are no longer part of the public API; import public symbols by name from their documented module."
+    },
+    {
+      "type": "feature",
+      "description": "XML payloads are now eagerly parsed before deserialization, improving performance for both `bytes` and `BytesReader` inputs."
+    },
+    {
+      "type": "enhancement",
+      "description": "Added support for Python 3.15."
+    }
+  ]
+}

{smithy_xml-0.2.0 → smithy_xml-0.3.0}/.gitignore

@@ -34,3 +34,6 @@ htmlcov
 *.egg-info
 dist
 .venv
+
+# make gen
+/workspace/

smithy_xml-0.3.0/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+## v0.3.0
+
+### Breaking Changes
+* Declared explicit `__all__` exports on all public modules. Names that were previously importable only incidentally (via `from module import *` or as un-annotated module attributes) are no longer part of the public API; import public symbols by name from their documented module.
+
+### Features
+* XML payloads are now eagerly parsed before deserialization, improving performance for both `bytes` and `BytesReader` inputs.
+
+### Enhancements
+* Added support for Python 3.15.
+
+## v0.2.0
+
+### Features
+* Added XML serialization support to `XMLCodec`.
+
+### Bug fixes
+* Fixed deserialization of `@xmlFlattened` structure lists and of prefixed `@xmlAttribute` names. The root element name is no longer validated, and a structure's `@xmlName` no longer renames members that target it.
+
+## v0.1.0
+
+### Features
+* Added initial support for XML deserialization in Smithy clients.

{smithy_xml-0.2.0 → smithy_xml-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: smithy-xml
-Version: 0.2.0
+Version: 0.3.0
 Summary: XML serialization and deserialization support for Smithy tooling.
 Project-URL: Changelog, https://github.com/smithy-lang/smithy-python/blob/develop/packages/smithy-xml/CHANGELOG.md
 Project-URL: Code, https://github.com/smithy-lang/smithy-python/blob/develop/packages/smithy-xml/
@@ -21,6 +21,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Libraries
@@ -32,3 +33,9 @@ Description-Content-Type: text/markdown
 
 This package provides generic XML serialization and deserialization support
 for Smithy clients and servers.
+
+## Deserialization
+
+`XMLCodec` eagerly parses `bytes` and `BytesReader` payloads before
+deserializing Smithy shapes. This improves deserialization performance while
+temporarily materializing the complete XML tree.

smithy_xml-0.3.0/README.md

@@ -0,0 +1,10 @@
+# smithy-xml
+
+This package provides generic XML serialization and deserialization support
+for Smithy clients and servers.
+
+## Deserialization
+
+`XMLCodec` eagerly parses `bytes` and `BytesReader` payloads before
+deserializing Smithy shapes. This improves deserialization performance while
+temporarily materializing the complete XML tree.

{smithy_xml-0.2.0 → smithy_xml-0.3.0}/pyproject.toml

@@ -22,6 +22,7 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Free Threading :: 2 - Beta",
   "Topic :: Software Development :: Libraries"

{smithy_xml-0.2.0 → smithy_xml-0.3.0}/src/smithy_xml/__init__.py

@@ -1,9 +1,8 @@
 #  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #  SPDX-License-Identifier: Apache-2.0
 
-from io import BytesIO
 from typing import Any
-from xml.etree.ElementTree import iterparse
+from xml.etree.ElementTree import Element, fromstring, parse
 
 from smithy_core.codecs import Codec
 from smithy_core.deserializers import ShapeDeserializer
@@ -13,11 +12,10 @@ from smithy_core.shapes import ShapeID
 from smithy_core.types import TimestampFormat
 
 from ._private.deserializers import XMLShapeDeserializer as _XMLShapeDeserializer
-from ._private.readers import XMLEventReader as _XMLEventReader
 from ._private.serializers import XMLShapeSerializer as _XMLShapeSerializer
 from .settings import XMLSettings
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __all__ = ("XMLCodec", "XMLSettings")
 
 
@@ -60,11 +58,25 @@ class XMLCodec(Codec):
         *,
         wrapper_elements: tuple[str, ...] = (),
     ) -> ShapeDeserializer:
-        if isinstance(source, bytes):
-            source = BytesIO(source)
-        reader = _XMLEventReader(
-            iterparse(source, events=("start", "end"))  # noqa: S314
+        root = (
+            fromstring(source)  # noqa: S314
+            if isinstance(source, bytes)
+            else parse(source).getroot()  # noqa: S314
         )
+        return self.create_deserializer_from_element(
+            root,
+            wrapper_elements=wrapper_elements,
+        )
+
+    def create_deserializer_from_element(
+        self,
+        root: Element,
+        *,
+        wrapper_elements: tuple[str, ...] = (),
+    ) -> ShapeDeserializer:
+        """Create a deserializer from an already parsed XML root element."""
         return _XMLShapeDeserializer(
-            settings=self._settings, reader=reader, wrapper_elements=wrapper_elements
+            settings=self._settings,
+            root=root,
+            wrapper_elements=wrapper_elements,
         )

smithy_xml-0.3.0/src/smithy_xml/_private/deserializers.py

@@ -0,0 +1,298 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#  SPDX-License-Identifier: Apache-2.0
+
+import datetime
+from base64 import b64decode
+from collections.abc import Callable, Iterable
+from decimal import Decimal
+from xml.etree.ElementTree import Element
+
+from smithy_core.deserializers import ShapeDeserializer, SpecificShapeDeserializer
+from smithy_core.documents import Document
+from smithy_core.exceptions import SmithyError
+from smithy_core.schemas import Schema
+from smithy_core.shapes import ShapeID
+from smithy_core.traits import (
+    TimestampFormatTrait,
+    XMLAttributeTrait,
+    XMLFlattenedTrait,
+)
+
+from ..settings import XMLSettings
+from .traits import member_xml_name
+
+
+def _local_name(tag: str) -> str:
+    """Strip namespace URI from an element tag: {uri}local -> local."""
+    if tag.startswith("{"):
+        return tag.split("}", 1)[1]
+    return tag
+
+
+def _local_attr_name(name: str) -> str:
+    """Strip a namespace prefix from a modeled attribute name: prefix:local -> local."""
+    return name.rpartition(":")[2]
+
+
+def _validate_element_name(expected: str, elem: Element) -> None:
+    """Raise XMLParseError if the element's local name doesn't match expected."""
+    found = _local_name(elem.tag)
+    if found != expected:
+        raise XMLParseError(f"Expected element '{expected}', got '{found}'")
+
+
+def _parse_xml_float(text: str) -> float:
+    """Parse an XML float string, handling NaN and Infinity."""
+    match text:
+        case "NaN":
+            return float("nan")
+        case "Infinity":
+            return float("inf")
+        case "-Infinity":
+            return float("-inf")
+        case _:
+            return float(text)
+
+
+class XMLParseError(SmithyError):
+    def __init__(self, message: str) -> None:
+        super().__init__(f"Error parsing XML: {message}")
+
+
+class XMLShapeDeserializer(ShapeDeserializer):
+    """Deserializer backed by a fully materialized ElementTree value."""
+
+    def __init__(
+        self,
+        settings: XMLSettings,
+        root: Element,
+        wrapper_elements: tuple[str, ...] = (),
+        *,
+        elements: tuple[Element, ...] | None = None,
+        xml_names: dict[ShapeID, dict[str, Schema]] | None = None,
+    ) -> None:
+        self._settings = settings
+        self._xml_names = xml_names if xml_names is not None else {}
+        self._elements = elements
+        self._from_wrapper = bool(wrapper_elements)
+
+        current = root
+        for index, wrapper in enumerate(wrapper_elements):
+            _validate_element_name(wrapper, current)
+            if index < len(wrapper_elements) - 1:
+                child = next(iter(current), None)
+                if child is None:
+                    raise XMLParseError(
+                        f"Expected wrapper element '{wrapper_elements[index + 1]}'"
+                    )
+                current = child
+        self._element = current
+
+    def is_null(self) -> bool:
+        return False
+
+    def read_null(self) -> None:
+        return None
+
+    def read_boolean(self, schema: Schema) -> bool:
+        text = self._read_text()
+        match text:
+            case "true":
+                return True
+            case "false":
+                return False
+            case _:
+                raise XMLParseError(f"Expected 'true' or 'false', got '{text}'")
+
+    def read_blob(self, schema: Schema) -> bytes:
+        return b64decode(self._read_text())
+
+    def read_integer(self, schema: Schema) -> int:
+        return int(self._read_text())
+
+    def read_float(self, schema: Schema) -> float:
+        return _parse_xml_float(self._read_text())
+
+    def read_big_decimal(self, schema: Schema) -> Decimal:
+        return Decimal(self._read_text())
+
+    def read_string(self, schema: Schema) -> str:
+        return self._read_text()
+
+    def read_document(self, schema: Schema) -> Document:
+        raise NotImplementedError("XML does not support document types")
+
+    def read_timestamp(self, schema: Schema) -> datetime.datetime:
+        format = self._settings.default_timestamp_format
+        if self._settings.use_timestamp_format:
+            if format_trait := schema.get_trait(TimestampFormatTrait):
+                format = format_trait.format
+        return format.deserialize(self._read_text())
+
+    def read_struct(
+        self,
+        schema: Schema,
+        consumer: Callable[[Schema, ShapeDeserializer], None],
+    ) -> None:
+        element = self._element
+        xml_names = self._get_xml_names(schema)
+
+        if not self._from_wrapper:
+            for member_schema in schema.members.values():
+                if member_schema.get_trait(XMLAttributeTrait) is None:
+                    continue
+                expected_name = _local_attr_name(member_xml_name(member_schema))
+                for attribute_name, value in element.attrib.items():
+                    if _local_name(attribute_name) == expected_name:
+                        consumer(
+                            member_schema,
+                            _AttributeDeserializer(value, self._settings),
+                        )
+                        break
+
+        flattened: dict[str, list[Element]] = {}
+        for child in element:
+            name = _local_name(child.tag)
+            member_schema = xml_names.get(name)
+            if member_schema is None:
+                continue
+            if member_schema.get_trait(XMLFlattenedTrait) is not None:
+                flattened.setdefault(name, []).append(child)
+            else:
+                consumer(member_schema, self._for_element(child))
+
+        for name, elements in flattened.items():
+            consumer(
+                xml_names[name],
+                self._for_elements(elements),
+            )
+
+    def read_list(
+        self,
+        schema: Schema,
+        consumer: Callable[[ShapeDeserializer], None],
+    ) -> None:
+        elements: Iterable[Element]
+        if schema.get_trait(XMLFlattenedTrait) is not None:
+            elements = self._elements or (self._element,)
+        else:
+            elements = self._element
+
+        for element in elements:
+            consumer(self._for_element(element))
+
+    def read_map(
+        self,
+        schema: Schema,
+        consumer: Callable[[str, ShapeDeserializer], None],
+    ) -> None:
+        key_tag = member_xml_name(schema.members["key"])
+        value_tag = member_xml_name(schema.members["value"])
+        entries: Iterable[Element]
+        if schema.get_trait(XMLFlattenedTrait) is not None:
+            entries = self._elements or (self._element,)
+        else:
+            entries = self._element
+
+        for entry in entries:
+            self._read_map_entry(entry, key_tag, value_tag, consumer)
+
+    def _read_map_entry(
+        self,
+        entry: Element,
+        key_tag: str,
+        value_tag: str,
+        consumer: Callable[[str, ShapeDeserializer], None],
+    ) -> None:
+        key: str | None = None
+        for child in entry:
+            name = _local_name(child.tag)
+            if name == key_tag:
+                key = child.text or ""
+            elif name == value_tag:
+                if key is None:
+                    raise XMLParseError(
+                        "Map key element must appear before value element"
+                    )
+                consumer(key, self._for_element(child))
+
+    def _read_text(self) -> str:
+        return self._element.text or ""
+
+    def _for_element(self, element: Element) -> "XMLShapeDeserializer":
+        return XMLShapeDeserializer(
+            settings=self._settings,
+            root=element,
+            xml_names=self._xml_names,
+        )
+
+    def _for_elements(self, elements: list[Element]) -> "XMLShapeDeserializer":
+        return XMLShapeDeserializer(
+            settings=self._settings,
+            root=elements[0],
+            elements=tuple(elements),
+            xml_names=self._xml_names,
+        )
+
+    def _get_xml_names(self, schema: Schema) -> dict[str, Schema]:
+        if schema.id in self._xml_names:
+            return self._xml_names[schema.id]
+        result = {
+            member_xml_name(member_schema): member_schema
+            for member_schema in schema.members.values()
+            if member_schema.get_trait(XMLAttributeTrait) is None
+        }
+        self._xml_names[schema.id] = result
+        return result
+
+
+class _AttributeDeserializer(SpecificShapeDeserializer):
+    """Deserializer for a value extracted from an XML attribute string."""
+
+    def __init__(self, value: str, settings: XMLSettings) -> None:
+        self._value = value
+        self._settings = settings
+
+    def read_string(self, schema: Schema) -> str:
+        return self._value
+
+    def read_boolean(self, schema: Schema) -> bool:
+        match self._value:
+            case "true":
+                return True
+            case "false":
+                return False
+            case _:
+                raise XMLParseError(f"Expected 'true' or 'false', got '{self._value}'")
+
+    def read_byte(self, schema: Schema) -> int:
+        return self.read_integer(schema)
+
+    def read_short(self, schema: Schema) -> int:
+        return self.read_integer(schema)
+
+    def read_integer(self, schema: Schema) -> int:
+        return int(self._value)
+
+    def read_long(self, schema: Schema) -> int:
+        return self.read_integer(schema)
+
+    def read_big_integer(self, schema: Schema) -> int:
+        return self.read_integer(schema)
+
+    def read_float(self, schema: Schema) -> float:
+        return _parse_xml_float(self._value)
+
+    def read_double(self, schema: Schema) -> float:
+        return self.read_float(schema)
+
+    def read_big_decimal(self, schema: Schema) -> Decimal:
+        return Decimal(self._value)
+
+    def read_timestamp(self, schema: Schema) -> datetime.datetime:
+        format = self._settings.default_timestamp_format
+        if self._settings.use_timestamp_format:
+            if format_trait := schema.get_trait(TimestampFormatTrait):
+                format = format_trait.format
+
+        return format.deserialize(self._value)

{smithy_xml-0.2.0 → smithy_xml-0.3.0}/src/smithy_xml/settings.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass
 
 from smithy_core.types import TimestampFormat
 
+__all__ = ["XMLSettings"]
+
 
 @dataclass(slots=True)
 class XMLSettings:

smithy_xml-0.2.0/CHANGELOG.md

@@ -1,14 +0,0 @@
-# Changelog
-
-## v0.2.0
-
-### Features
-* Added XML serialization support to `XMLCodec`.
-
-### Bug fixes
-* Fixed deserialization of `@xmlFlattened` structure lists and of prefixed `@xmlAttribute` names. The root element name is no longer validated, and a structure's `@xmlName` no longer renames members that target it.
-
-## v0.1.0
-
-### Features
-* Added initial support for XML deserialization in Smithy clients.

smithy_xml-0.2.0/README.md

@@ -1,4 +0,0 @@
-# smithy-xml
-
-This package provides generic XML serialization and deserialization support
-for Smithy clients and servers.

smithy_xml-0.2.0/src/smithy_xml/_private/deserializers.py

@@ -1,365 +0,0 @@
-#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#  SPDX-License-Identifier: Apache-2.0
-
-import datetime
-from base64 import b64decode
-from collections.abc import Callable
-from decimal import Decimal
-from xml.etree.ElementTree import Element
-
-from smithy_core.deserializers import ShapeDeserializer, SpecificShapeDeserializer
-from smithy_core.documents import Document
-from smithy_core.exceptions import SmithyError
-from smithy_core.schemas import Schema
-from smithy_core.shapes import ShapeID
-from smithy_core.traits import (
-    TimestampFormatTrait,
-    XMLAttributeTrait,
-    XMLFlattenedTrait,
-)
-
-from ..settings import XMLSettings
-from .readers import XMLEvent, XMLEventReader
-from .traits import member_xml_name
-
-
-def _local_name(tag: str) -> str:
-    """Strip namespace URI from an element tag: {uri}local -> local."""
-    if tag.startswith("{"):
-        return tag.split("}", 1)[1]
-    return tag
-
-
-def _local_attr_name(name: str) -> str:
-    """Strip a namespace prefix from a modeled attribute name: prefix:local -> local."""
-    return name.rpartition(":")[2]
-
-
-def _validate_element_name(expected: str, elem: Element) -> None:
-    """Raise XMLParseError if the element's local name doesn't match expected."""
-    found = _local_name(elem.tag)
-    if found != expected:
-        raise XMLParseError(f"Expected element '{expected}', got '{found}'")
-
-
-def _parse_xml_float(text: str) -> float:
-    """Parse an XML float string, handling NaN and Infinity."""
-    match text:
-        case "NaN":
-            return float("nan")
-        case "Infinity":
-            return float("inf")
-        case "-Infinity":
-            return float("-inf")
-        case _:
-            return float(text)
-
-
-class XMLParseError(SmithyError):
-    def __init__(self, message: str) -> None:
-        super().__init__(f"Error parsing XML: {message}")
-
-
-class XMLShapeDeserializer(ShapeDeserializer):
-    """Deserializer that reads XML from a streaming pull parser."""
-
-    def __init__(
-        self,
-        settings: XMLSettings,
-        reader: XMLEventReader,
-        wrapper_elements: tuple[str, ...] = (),
-    ) -> None:
-        self._settings = settings
-        self._reader = reader
-        self._xml_names: dict[ShapeID, dict[str, Schema]] = {}
-        self._preconsumed_start: Element | None = None
-
-        # Wrapper elements are protocol transport containers (e.g. awsQuery's
-        # <OpResponse><OpResult>). The last wrapper's start element is kept
-        # so that the next read can reuse it.
-        for wrapper in wrapper_elements:
-            event = next(self._reader)
-            if event.type != "start":
-                raise XMLParseError(f"Expected start element, got '{event.type}'")
-            _validate_element_name(wrapper, event.elem)
-            self._preconsumed_start = event.elem
-
-    def is_null(self) -> bool:
-        return False
-
-    def read_null(self) -> None:
-        return None
-
-    def read_boolean(self, schema: Schema) -> bool:
-        text = self._read_text()
-        match text:
-            case "true":
-                return True
-            case "false":
-                return False
-            case _:
-                raise XMLParseError(f"Expected 'true' or 'false', got '{text}'")
-
-    def read_blob(self, schema: Schema) -> bytes:
-        return b64decode(self._read_text())
-
-    def read_integer(self, schema: Schema) -> int:
-        return int(self._read_text())
-
-    def read_float(self, schema: Schema) -> float:
-        return _parse_xml_float(self._read_text())
-
-    def read_big_decimal(self, schema: Schema) -> Decimal:
-        return Decimal(self._read_text())
-
-    def read_string(self, schema: Schema) -> str:
-        return self._read_text()
-
-    def read_document(self, schema: Schema) -> Document:
-        raise NotImplementedError("XML does not support document types")
-
-    def read_timestamp(self, schema: Schema) -> datetime.datetime:
-        format = self._settings.default_timestamp_format
-        if self._settings.use_timestamp_format:
-            if format_trait := schema.get_trait(TimestampFormatTrait):
-                format = format_trait.format
-
-        text = self._read_text()
-        return format.deserialize(text)
-
-    def read_struct(
-        self,
-        schema: Schema,
-        consumer: Callable[[Schema, "ShapeDeserializer"], None],
-    ) -> None:
-        xml_names = self._get_xml_names(schema)
-        start_from_wrapper = self._preconsumed_start is not None
-        start_elem = self._consume_start_event()
-
-        # Wrapper elements are protocol transport containers, not modeled structs,
-        # so their attributes cannot be deserialized as struct members.
-        if not start_from_wrapper:
-            for member_schema in schema.members.values():
-                if member_schema.get_trait(XMLAttributeTrait) is None:
-                    continue
-                # Prefixed names (e.g. ``xsi:name``) are parsed into a
-                # namespace-qualified key, so only the local parts are compared.
-                expected_attr_name = _local_attr_name(member_xml_name(member_schema))
-                for attr_name, attr_value in start_elem.attrib.items():
-                    attr_local_name = _local_name(attr_name)
-                    if attr_local_name == expected_attr_name:
-                        consumer(
-                            member_schema,
-                            _AttributeDeserializer(attr_value, self._settings),
-                        )
-                        break
-
-        # Flattened members lack an enclosing element, so there is no way to
-        # know when all items have been parsed. Their events are collected
-        # during iteration and replayed through a bounded reader afterwards.
-        flattened_buffers: dict[str, list[XMLEvent]] = {}
-        flattened_names = {
-            xml_name: member_schema
-            for xml_name, member_schema in xml_names.items()
-            if member_schema.get_trait(XMLFlattenedTrait) is not None
-        }
-
-        while self._reader.peek().type != "end":
-            tag = _local_name(self._reader.peek().elem.tag)
-
-            if tag in flattened_names:
-                flattened_buffers.setdefault(tag, []).extend(self._buffer_element())
-            elif tag in xml_names:
-                consumer(xml_names[tag], self)
-            else:
-                # Skip unknown tag
-                self._consume_start_event()
-                self._skip_to_end()
-
-        next(self._reader)
-
-        for tag, events in flattened_buffers.items():
-            member_schema = flattened_names[tag]
-            buffered_de = XMLShapeDeserializer(
-                self._settings,
-                XMLEventReader(iter(events)),
-            )
-            consumer(member_schema, buffered_de)
-
-    def read_list(
-        self,
-        schema: Schema,
-        consumer: Callable[["ShapeDeserializer"], None],
-    ) -> None:
-        is_flattened = schema.get_trait(XMLFlattenedTrait) is not None
-        if not is_flattened:
-            self._consume_start_event()
-            while self._reader.peek().type != "end":
-                consumer(self)
-        else:
-            while self._reader.has_next():
-                consumer(self)
-
-        if not is_flattened:
-            next(self._reader)
-
-    def read_map(
-        self,
-        schema: Schema,
-        consumer: Callable[[str, "ShapeDeserializer"], None],
-    ) -> None:
-        is_flattened = schema.get_trait(XMLFlattenedTrait) is not None
-        key_schema = schema.members["key"]
-        value_schema = schema.members["value"]
-        key_tag = member_xml_name(key_schema)
-        value_tag = member_xml_name(value_schema)
-
-        if not is_flattened:
-            self._consume_start_event()
-            while self._reader.peek().type != "end":
-                self._read_map_entry(key_tag, value_tag, consumer)
-        else:
-            while self._reader.has_next():
-                self._read_map_entry(key_tag, value_tag, consumer)
-
-        if not is_flattened:
-            next(self._reader)
-
-    def _read_text(self) -> str:
-        """Consume a complete element (start through end) and return its text."""
-        elem = self._consume_start_event()
-        self._skip_to_end()
-        # elem.text is populated only after consuming the "end" event
-        return elem.text or ""
-
-    def _consume_start_event(self) -> Element:
-        """Consume and return the next start element.
-
-        If a start element was pre-consumed (e.g. from consuming wrapper elements),
-        it is returned first and cleared.
-        """
-        if self._preconsumed_start is not None:
-            elem = self._preconsumed_start
-            self._preconsumed_start = None
-            return elem
-        event = next(self._reader)
-        if event.type != "start":
-            raise XMLParseError(f"Expected start element, got '{event.type}'")
-        return event.elem
-
-    def _skip_to_end(self) -> None:
-        """Skip to the matching end event. Assumes start was already consumed."""
-        depth = 1
-        while depth > 0:
-            event = next(self._reader)
-            if event.type == "start":
-                depth += 1
-            elif event.type == "end":
-                depth -= 1
-
-    def _buffer_element(self) -> list[XMLEvent]:
-        """Buffer a complete element's events (start through matching end)."""
-        events: list[XMLEvent] = []
-        event = next(self._reader)
-        events.append(event)
-        depth = 1
-        while depth > 0:
-            event = next(self._reader)
-            events.append(event)
-            if event.type == "start":
-                depth += 1
-            elif event.type == "end":
-                depth -= 1
-        return events
-
-    def _get_xml_names(self, schema: Schema) -> dict[str, Schema]:
-        """Get or build the XML element name -> member schema mapping for a shape."""
-        if schema.id in self._xml_names:
-            return self._xml_names[schema.id]
-        result: dict[str, Schema] = {}
-        for member_schema in schema.members.values():
-            if member_schema.get_trait(XMLAttributeTrait) is not None:
-                continue
-            xml_name = member_xml_name(member_schema)
-            result[xml_name] = member_schema
-        self._xml_names[schema.id] = result
-        return result
-
-    def _read_map_entry(
-        self,
-        key_tag: str,
-        value_tag: str,
-        consumer: Callable[[str, "ShapeDeserializer"], None],
-    ) -> None:
-        """Read one map entry element and emit key/value pairs via consumer."""
-        self._consume_start_event()
-
-        key: str | None = None
-        while self._reader.peek().type != "end":
-            child_tag = _local_name(self._reader.peek().elem.tag)
-            if child_tag == key_tag:
-                key = self._read_text()
-            elif child_tag == value_tag:
-                if key is None:
-                    raise XMLParseError(
-                        "Map key element must appear before value element"
-                    )
-                consumer(key, self)
-            else:
-                # Skip unknown child tag
-                self._consume_start_event()
-                self._skip_to_end()
-
-        next(self._reader)
-
-
-class _AttributeDeserializer(SpecificShapeDeserializer):
-    """Deserializer for a value extracted from an XML attribute string."""
-
-    def __init__(self, value: str, settings: XMLSettings) -> None:
-        self._value = value
-        self._settings = settings
-
-    def read_string(self, schema: Schema) -> str:
-        return self._value
-
-    def read_boolean(self, schema: Schema) -> bool:
-        match self._value:
-            case "true":
-                return True
-            case "false":
-                return False
-            case _:
-                raise XMLParseError(f"Expected 'true' or 'false', got '{self._value}'")
-
-    def read_byte(self, schema: Schema) -> int:
-        return self.read_integer(schema)
-
-    def read_short(self, schema: Schema) -> int:
-        return self.read_integer(schema)
-
-    def read_integer(self, schema: Schema) -> int:
-        return int(self._value)
-
-    def read_long(self, schema: Schema) -> int:
-        return self.read_integer(schema)
-
-    def read_big_integer(self, schema: Schema) -> int:
-        return self.read_integer(schema)
-
-    def read_float(self, schema: Schema) -> float:
-        return _parse_xml_float(self._value)
-
-    def read_double(self, schema: Schema) -> float:
-        return self.read_float(schema)
-
-    def read_big_decimal(self, schema: Schema) -> Decimal:
-        return Decimal(self._value)
-
-    def read_timestamp(self, schema: Schema) -> datetime.datetime:
-        format = self._settings.default_timestamp_format
-        if self._settings.use_timestamp_format:
-            if format_trait := schema.get_trait(TimestampFormatTrait):
-                format = format_trait.format
-
-        return format.deserialize(self._value)

smithy_xml-0.2.0/src/smithy_xml/_private/readers.py

@@ -1,55 +0,0 @@
-#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#  SPDX-License-Identifier: Apache-2.0
-
-from collections.abc import Iterator
-from typing import NamedTuple
-from xml.etree.ElementTree import Element
-
-
-class XMLEvent(NamedTuple):
-    type: str
-    elem: Element
-
-
-class XMLEventReader:
-    """Buffered iterator over XML pull parser events with peek support.
-
-    Wraps an iterator of ``(event, element)`` tuples — either from
-    ``iterparse`` (streaming from a byte source) or from an in-memory list
-    (for flattened member replay).
-    """
-
-    def __init__(self, events: Iterator[tuple[str, Element] | XMLEvent]) -> None:
-        self._iter = events
-        self._pending: XMLEvent | None = None
-
-    def __iter__(self):
-        return self
-
-    def __next__(self) -> XMLEvent:
-        if self._pending is not None:
-            result = self._pending
-            self._pending = None
-            return result
-        return self._next()
-
-    def _next(self) -> XMLEvent:
-        event = next(self._iter)
-        if isinstance(event, XMLEvent):
-            return event
-        event_type, elem = event
-        return XMLEvent(event_type, elem)
-
-    def has_next(self) -> bool:
-        if self._pending is not None:
-            return True
-        try:
-            self._pending = self._next()
-            return True
-        except StopIteration:
-            return False
-
-    def peek(self) -> XMLEvent:
-        if self._pending is None:
-            self._pending = self._next()
-        return self._pending