smithy-json 0.0.1__tar.gz

smithy_json-0.0.1/.gitignore

@@ -0,0 +1,36 @@
+# Eclipse
+.classpath
+.project
+.settings/
+
+# Intellij
+.idea/
+*.iml
+*.iws
+
+# VS Code
+.vscode/
+
+# Mac
+.DS_Store
+
+# Maven
+target/
+**/dependency-reduced-pom.xml
+
+# Gradle
+**/.gradle
+build/
+*/out/
+**/*/out/
+
+# Python
+__pycache__
+*.swp
+.mypy_cache
+.coverage
+coverage.xml
+htmlcov
+*.egg-info
+dist
+.venv

smithy_json-0.0.1/CHANGES.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## Unreleased
+
+* <Add new items here>
+
+## v0.0.1
+
+### Feature
+* Added support for json primitives in Smithy clients.

smithy_json-0.0.1/NOTICE

@@ -0,0 +1 @@
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

smithy_json-0.0.1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: smithy-json
+Version: 0.0.1
+Summary: JSON serialization and deserialization support for Smithy tooling.
+License-File: NOTICE
+Requires-Python: >=3.12
+Requires-Dist: ijson>=3.3.0
+Requires-Dist: smithy-core
+Description-Content-Type: text/markdown
+
+# smithy-json
+
+This package provides generic JSON serialization and deserialization support
+for Smithy clients and servers.

smithy_json-0.0.1/README.md

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

smithy_json-0.0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "smithy-json"
+version = "0.0.1"
+description = "JSON serialization and deserialization support for Smithy tooling."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "ijson>=3.3.0",
+    "smithy-core",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+exclude = [
+  "tests",
+]
+
+[tool.ruff]
+src = ["src"]

smithy_json-0.0.1/src/smithy_json/__init__.py

@@ -0,0 +1,64 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#  SPDX-License-Identifier: Apache-2.0
+import importlib.metadata
+from io import BytesIO
+
+from smithy_core.codecs import Codec
+from smithy_core.deserializers import ShapeDeserializer
+from smithy_core.interfaces import BytesReader, BytesWriter
+from smithy_core.serializers import ShapeSerializer
+from smithy_core.types import TimestampFormat
+
+from ._private.deserializers import JSONShapeDeserializer as _JSONShapeDeserializer
+from ._private.serializers import JSONShapeSerializer as _JSONShapeSerializer
+
+__version__: str = importlib.metadata.version("smithy-json")
+
+
+class JSONCodec(Codec):
+    """A codec for converting shapes to/from JSON."""
+
+    _use_json_name: bool
+    _use_timestamp_format: bool
+    _default_timestamp_format: TimestampFormat
+
+    def __init__(
+        self,
+        use_json_name: bool = True,
+        use_timestamp_format: bool = True,
+        default_timestamp_format: TimestampFormat = TimestampFormat.DATE_TIME,
+    ) -> None:
+        """Initializes a JSONCodec.
+
+        :param use_json_name: Whether the codec should use `smithy.api#jsonName` trait,
+            if present.
+        :param use_timestamp_format: Whether the codec should use the
+            `smithy.api#timestampFormat` trait, if present.
+        :param default_timestamp_format: The default timestamp format to use if the
+            `smithy.api#timestampFormat` trait is not enabled or not present.
+        """
+        self._use_json_name = use_json_name
+        self._use_timestamp_format = use_timestamp_format
+        self._default_timestamp_format = default_timestamp_format
+
+    @property
+    def media_type(self) -> str:
+        return "application/json"
+
+    def create_serializer(self, sink: BytesWriter) -> "ShapeSerializer":
+        return _JSONShapeSerializer(
+            sink,
+            use_json_name=self._use_json_name,
+            use_timestamp_format=self._use_timestamp_format,
+            default_timestamp_format=self._default_timestamp_format,
+        )
+
+    def create_deserializer(self, source: bytes | BytesReader) -> "ShapeDeserializer":
+        if isinstance(source, bytes):
+            source = BytesIO(source)
+        return _JSONShapeDeserializer(
+            source,
+            use_json_name=self._use_json_name,
+            use_timestamp_format=self._use_timestamp_format,
+            default_timestamp_format=self._default_timestamp_format,
+        )

smithy_json-0.0.1/src/smithy_json/_private/__init__.py

@@ -0,0 +1,11 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#  SPDX-License-Identifier: Apache-2.0
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class Flushable(Protocol):
+    """A protocol for objects that can be flushed."""
+
+    def flush(self) -> None: ...

smithy_json-0.0.1/src/smithy_json/_private/deserializers.py

@@ -0,0 +1,279 @@
+#  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, Iterator, Mapping, Sequence
+from decimal import Decimal
+from typing import Literal, NamedTuple, Protocol, cast
+
+import ijson  # type: ignore
+from ijson.common import ObjectBuilder  # type: ignore
+from smithy_core.deserializers import ShapeDeserializer
+from smithy_core.documents import Document
+from smithy_core.exceptions import SmithyException
+from smithy_core.interfaces import BytesReader
+from smithy_core.schemas import Schema
+from smithy_core.shapes import ShapeID, ShapeType
+from smithy_core.traits import JSONNameTrait, TimestampFormatTrait
+from smithy_core.types import TimestampFormat
+
+from .documents import JSONDocument
+
+# TODO: put these type hints in a pyi somewhere. There here because ijson isn't
+# typed.
+type JSONParseEventType = Literal[
+    "null",
+    "string",
+    "number",
+    "boolean",
+    "start_array",
+    "end_array",
+    "start_map",
+    "map_key",
+    "end_map",
+]
+
+type JSONParseEventValue = str | int | float | Decimal | bool | None
+
+type JSON = Mapping[str, "JSON"] | Sequence["JSON"] | JSONParseEventValue
+
+
+class JSONParseEvent(NamedTuple):
+    path: str
+    type: JSONParseEventType
+    value: JSONParseEventValue
+
+
+class JSONTokenError(SmithyException):
+    def __init__(self, expected: str, event: JSONParseEvent) -> None:
+        super().__init__(
+            f"Error parsing JSON. Expected token of type `{expected}` at path "
+            f"`{event.path}`, but found: `{event.type}`: {event.value}"
+        )
+
+
+class TypedObjectBuilder(Protocol):
+    value: JSON
+
+    def event(self, event: JSONParseEventType, value: JSONParseEventValue): ...
+
+
+class BufferedParser:
+    """A wrapper around the ijson parser that allows peeking."""
+
+    def __init__(
+        self, stream: Iterator[tuple[str, JSONParseEventType, JSONParseEventValue]]
+    ) -> None:
+        self._stream = stream
+        self._pending: JSONParseEvent | None = None
+
+    def __iter__(self):
+        return self
+
+    def __next__(self) -> JSONParseEvent:
+        if self._pending is not None:
+            result = self._pending
+            self._pending = None
+            return result
+        return self._next()
+
+    def _next(self) -> JSONParseEvent:
+        return JSONParseEvent(*next(self._stream))
+
+    def peek(self) -> JSONParseEvent:
+        if self._pending is None:
+            self._pending = self._next()
+        return self._pending
+
+
+class JSONShapeDeserializer(ShapeDeserializer):
+    def __init__(
+        self,
+        source: BytesReader,
+        *,
+        use_json_name: bool = True,
+        use_timestamp_format: bool = True,
+        default_timestamp_format: TimestampFormat = TimestampFormat.DATE_TIME,
+    ) -> None:
+        self._stream = BufferedParser(ijson.parse(source))
+        self._use_json_name = use_json_name
+        self._use_timestamp_format = use_timestamp_format
+        self._default_timestamp_format = default_timestamp_format
+
+        # A mapping of json name to member name for each shape. Since the deserializer
+        # is shared and we don't know which shapes will be deserialized, this is
+        # populated on an as-needed basis.
+        self._json_names: dict[ShapeID, dict[str, str]] = {}
+
+    def is_null(self) -> bool:
+        return self._stream.peek().type == "null"
+
+    def read_null(self) -> None:
+        event = next(self._stream)
+        if event.value is not None:
+            raise JSONTokenError("null", event)
+        return None
+
+    def read_boolean(self, schema: Schema) -> bool:
+        event = next(self._stream)
+        if not isinstance(event.value, bool):
+            raise JSONTokenError("boolean", event)
+        return event.value
+
+    def read_blob(self, schema: Schema) -> bytes:
+        event = next(self._stream)
+        if event.type != "string" or not isinstance(event.value, str):
+            raise JSONTokenError("string", event)
+        return b64decode(event.value)
+
+    def read_integer(self, schema: Schema) -> int:
+        event = next(self._stream)
+        if not isinstance(event.value, int):
+            raise JSONTokenError("number", event)
+        return event.value
+
+    def read_float(self, schema: Schema) -> float:
+        event = next(self._stream)
+        match event.value:
+            case Decimal():
+                return float(event.value)
+            case int() | float():
+                return event.value
+            case "Infinity" | "-Infinity" | "NaN":
+                return float(event.value)
+            case _:
+                raise JSONTokenError("number", event)
+
+    def read_big_decimal(self, schema: Schema) -> Decimal:
+        event = next(self._stream)
+        match event.value:
+            case Decimal():
+                return event.value
+            case int() | float():
+                return Decimal.from_float(event.value)
+            case _:
+                raise JSONTokenError("number", event)
+
+    def read_string(self, schema: Schema) -> str:
+        event = next(self._stream)
+        if event.type not in ("string", "map_key") or not isinstance(event.value, str):
+            raise JSONTokenError("string | map_key", event)
+        return event.value
+
+    def read_document(self, schema: Schema) -> Document:
+        start = next(self._stream)
+        if start.type not in ("start_map", "start_array"):
+            return JSONDocument(
+                start.value,
+                schema=schema,
+                use_json_name=self._use_json_name,
+                default_timestamp_format=self._default_timestamp_format,
+                use_timestamp_format=self._use_timestamp_format,
+            )
+
+        end_type = "end_map" if start.type == "start_map" else "end_array"
+        builder = cast(TypedObjectBuilder, ObjectBuilder())
+        builder.event(start.type, start.value)
+        while (
+            event := next(self._stream)
+        ).path != start.path or event.type != end_type:
+            builder.event(event.type, event.value)
+
+        return JSONDocument(
+            builder.value,
+            schema=schema,
+            use_json_name=self._use_json_name,
+            default_timestamp_format=self._default_timestamp_format,
+            use_timestamp_format=self._use_timestamp_format,
+        )
+
+    def read_timestamp(self, schema: Schema) -> datetime.datetime:
+        format = self._default_timestamp_format
+        if self._use_timestamp_format:
+            if format_trait := schema.get_trait(TimestampFormatTrait):
+                format = format_trait.format
+
+        match format:
+            case TimestampFormat.EPOCH_SECONDS:
+                return format.deserialize(self.read_float(schema=schema))
+            case _:
+                return format.deserialize(self.read_string(schema=schema))
+
+    def read_struct(
+        self, schema: Schema, consumer: Callable[[Schema, "ShapeDeserializer"], None]
+    ):
+        event = next(self._stream)
+        if event.type != "start_map":
+            raise JSONTokenError("start_map", event)
+
+        while self._stream.peek().type != "end_map":
+            key = self.read_string(schema=schema)
+            member = self._resolve_member(schema=schema, key=key)
+            if not member:
+                self._skip()
+                continue
+            if self.is_null() and member.shape_type is not ShapeType.DOCUMENT:
+                self.read_null()
+                continue
+            consumer(member, self)
+
+        next(self._stream)
+
+    def _resolve_member(self, schema: Schema, key: str) -> Schema | None:
+        if self._use_json_name:
+            if schema.id not in self._json_names:
+                self._cache_json_names(schema=schema)
+            if key in self._json_names[schema.id]:
+                return schema.members.get(self._json_names[schema.id][key])
+            return None
+
+        return schema.members.get(key)
+
+    def _cache_json_names(self, schema: Schema):
+        result: dict[str, str] = {}
+        for member_name, member_schema in schema.members.items():
+            name: str = member_name
+            if json_name := member_schema.get_trait(JSONNameTrait):
+                name = json_name.value
+            result[name] = member_name
+        self._json_names[schema.id] = result
+
+    def read_list(
+        self, schema: Schema, consumer: Callable[["ShapeDeserializer"], None]
+    ):
+        event = next(self._stream)
+        if event.type != "start_array":
+            raise JSONTokenError("start_array", event)
+
+        while self._stream.peek().type != "end_array":
+            consumer(self)
+
+        next(self._stream)
+
+    def read_map(
+        self,
+        schema: Schema,
+        consumer: Callable[[str, "ShapeDeserializer"], None],
+    ):
+        event = next(self._stream)
+        if event.type != "start_map":
+            raise JSONTokenError("start_map", event)
+
+        key_schema = schema.members["key"]
+        while self._stream.peek().type != "end_map":
+            consumer(self.read_string(schema=key_schema), self)
+
+        next(self._stream)
+
+    def _skip(self) -> None:
+        start = next(self._stream)
+        if start.type not in ("start_map", "start_array"):
+            return
+
+        end_type = "end_map" if start.type == "start_map" else "end_array"
+
+        while (
+            event := next(self._stream)
+        ).path != start.path or event.type != end_type:
+            continue

smithy_json-0.0.1/src/smithy_json/_private/documents.py

@@ -0,0 +1,149 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#  SPDX-License-Identifier: Apache-2.0
+
+from base64 import b64decode
+from collections.abc import Mapping
+from datetime import datetime
+from decimal import Decimal
+
+from smithy_core.documents import Document, DocumentValue
+from smithy_core.prelude import DOCUMENT
+from smithy_core.schemas import Schema
+from smithy_core.shapes import ShapeType
+from smithy_core.traits import JSONNameTrait, TimestampFormatTrait
+from smithy_core.types import TimestampFormat
+from smithy_core.utils import expect_type
+
+
+class JSONDocument(Document):
+    _schema: Schema
+    _json_names: dict[str, str]
+
+    def __init__(
+        self,
+        value: DocumentValue | dict[str, "Document"] | list["Document"],
+        *,
+        schema: Schema = DOCUMENT,
+        use_json_name: bool = True,
+        use_timestamp_format: bool = True,
+        default_timestamp_format: TimestampFormat = TimestampFormat.DATE_TIME,
+    ) -> None:
+        super().__init__(value, schema=schema)
+        self._use_json_name = use_json_name
+        self._use_timestamp_format = use_timestamp_format
+        self._default_timestamp_format = default_timestamp_format
+        self._json_names = {}
+
+        if use_json_name and schema.shape_type in (
+            ShapeType.STRUCTURE,
+            ShapeType.UNION,
+        ):
+            for member_name, member_schema in schema.members.items():
+                if json_name := member_schema.get_trait(JSONNameTrait):
+                    self._json_names[json_name.value] = member_name
+
+    def as_blob(self) -> bytes:
+        return b64decode(expect_type(str, self._value))
+
+    def as_float(self) -> float:
+        # Floats are returned as Decimals by default in ijson, which is the correct
+        # behavior, since technically JSON numbers have arbitrary precision.
+        return float(expect_type(Decimal, self._value))
+
+    def as_timestamp(self) -> datetime:
+        format = self._default_timestamp_format
+        if self._use_timestamp_format:
+            if format_trait := self._schema.get_trait(TimestampFormatTrait):
+                format = format_trait.format
+
+        match self._value:
+            case float() | int() | str():
+                return format.deserialize(self._value)
+            case Decimal():
+                return format.deserialize(float(self._value))
+            case datetime():
+                return self._value
+            case _:
+                raise Exception(
+                    f"Expected number, but found {type(self._value)}: {self._value!r}"
+                )
+
+    def as_value(self) -> DocumentValue:
+        if self.is_none():
+            return None
+
+        match self.shape_type:
+            case ShapeType.STRING | ShapeType.ENUM:
+                return self.as_string()
+            case ShapeType.BOOLEAN:
+                return self.as_boolean()
+            case (
+                ShapeType.BYTE
+                | ShapeType.SHORT
+                | ShapeType.INTEGER
+                | ShapeType.INT_ENUM
+                | ShapeType.LONG
+                | ShapeType.BIG_INTEGER
+            ):
+                return self.as_integer()
+            case ShapeType.FLOAT | ShapeType.DOUBLE:
+                return self.as_float()
+            case ShapeType.BIG_DECIMAL:
+                return self.as_decimal()
+            case ShapeType.BLOB:
+                return self.as_blob()
+            case ShapeType.TIMESTAMP:
+                return self.as_timestamp()
+            case ShapeType.LIST:
+                return [e.as_value() for e in self.as_list()]
+            case ShapeType.MAP | ShapeType.STRUCTURE | ShapeType.UNION:
+                return {k: v.as_value() for k, v in self.as_map().items()}
+            case _:
+                return super().as_value()
+
+    def _new_document(
+        self,
+        value: DocumentValue | dict[str, "Document"] | list["Document"],
+        schema: Schema,
+    ) -> "Document":
+        return JSONDocument(
+            value,
+            schema=schema,
+            use_json_name=self._use_json_name,
+            use_timestamp_format=self._use_timestamp_format,
+            default_timestamp_format=self._default_timestamp_format,
+        )
+
+    def _wrap_map(self, value: Mapping[str, DocumentValue]) -> dict[str, "Document"]:
+        if self._schema.shape_type not in (ShapeType.STRUCTURE, ShapeType.UNION):
+            return super()._wrap_map(value)
+
+        result: dict[str, Document] = {}
+        for k, v in value.items():
+            member_name = self._json_names.get(k, k)
+            result[member_name] = self._new_document(
+                v, self._schema.members[member_name]
+            )
+        return result
+
+    def __setitem__(
+        self,
+        key: str | int,
+        value: "Document | list[Document] | dict[str, Document] | DocumentValue",
+    ) -> None:
+        if isinstance(key, str) and self._schema.shape_type in (
+            ShapeType.STRUCTURE,
+            ShapeType.UNION,
+        ):
+            member_name = self._json_names.get(key, key)
+            schema = self._schema.members[member_name]
+
+            if not isinstance(value, Document):
+                value = Document(value, schema=schema)
+            else:
+                value = value._with_schema(schema)
+
+            self.as_map()[member_name] = value
+            self._raw_value = None
+        else:
+            super().__setitem__(key, value)

smithy_json-0.0.1/src/smithy_json/_private/serializers.py

@@ -0,0 +1,324 @@
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#  SPDX-License-Identifier: Apache-2.0
+
+from base64 import b64encode
+from collections.abc import Callable, Mapping, Sequence
+from contextlib import AbstractContextManager
+from datetime import datetime
+from decimal import Decimal
+from io import BufferedWriter, RawIOBase
+from types import TracebackType
+from typing import Self
+
+from smithy_core.documents import Document, DocumentValue
+from smithy_core.interfaces import BytesWriter
+from smithy_core.schemas import Schema
+from smithy_core.serializers import (
+    InterceptingSerializer,
+    MapSerializer,
+    ShapeSerializer,
+)
+from smithy_core.traits import JSONNameTrait, TimestampFormatTrait
+from smithy_core.types import TimestampFormat
+
+from . import Flushable
+
+_INF: float = float("inf")
+_NEG_INF: float = float("-inf")
+
+
+class JSONShapeSerializer(ShapeSerializer):
+    _stream: "StreamingJSONEncoder"
+    _use_json_name: bool
+    _use_timestamp_format: bool
+    _default_timestamp_format: TimestampFormat
+
+    def __init__(
+        self,
+        sink: BytesWriter,
+        use_json_name: bool = True,
+        use_timestamp_format: bool = True,
+        default_timestamp_format: TimestampFormat = TimestampFormat.DATE_TIME,
+    ) -> None:
+        self._stream = StreamingJSONEncoder(sink)
+        self._use_json_name = use_json_name
+        self._use_timestamp_format = use_timestamp_format
+        self._default_timestamp_format = default_timestamp_format
+
+    def begin_struct(
+        self, schema: "Schema"
+    ) -> AbstractContextManager["ShapeSerializer"]:
+        return JSONStructSerializer(self._stream, self, self._use_json_name)
+
+    def begin_list(
+        self, schema: "Schema", size: int
+    ) -> AbstractContextManager["ShapeSerializer"]:
+        return JSONListSerializer(self._stream, self)
+
+    def begin_map(
+        self, schema: "Schema", size: int
+    ) -> AbstractContextManager["MapSerializer"]:
+        return JSONMapSerializer(self._stream, self)
+
+    def write_null(self, schema: "Schema") -> None:
+        self._stream.write_null()
+
+    def write_boolean(self, schema: "Schema", value: bool) -> None:
+        self._stream.write_bool(value)
+
+    def write_integer(self, schema: "Schema", value: int) -> None:
+        self._stream.write_int(value)
+
+    def write_float(self, schema: "Schema", value: float) -> None:
+        self._stream.write_float(value)
+
+    def write_big_decimal(self, schema: "Schema", value: Decimal) -> None:
+        self._stream.write_float(value)
+
+    def write_string(self, schema: "Schema", value: str) -> None:
+        self._stream.write_string(value)
+
+    def write_blob(self, schema: "Schema", value: bytes) -> None:
+        self._stream.write_string(b64encode(value).decode("utf-8"))
+
+    def write_timestamp(self, schema: "Schema", value: datetime) -> None:
+        format = self._default_timestamp_format
+        if self._use_timestamp_format:
+            if format_trait := schema.get_trait(TimestampFormatTrait):
+                format = format_trait.format
+
+        self._stream.write_document_value(format.serialize(value))
+
+    def write_document(self, schema: "Schema", value: Document) -> None:
+        value.serialize_contents(self)
+
+    def flush(self) -> None:
+        self._stream.flush()
+
+
+class JSONStructSerializer(InterceptingSerializer):
+    _stream: "StreamingJSONEncoder"
+    _parent: JSONShapeSerializer
+    _use_json_name: bool
+    _is_first_member = True
+
+    def __init__(
+        self,
+        stream: "StreamingJSONEncoder",
+        parent: JSONShapeSerializer,
+        use_json_name: bool,
+    ) -> None:
+        self._stream = stream
+        self._parent = parent
+        self._use_json_name = use_json_name
+
+    def __enter__(self) -> Self:
+        self._stream.write_object_start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        if not exc_value:
+            self._stream.write_object_end()
+
+    def before(self, schema: "Schema") -> ShapeSerializer:
+        if self._is_first_member:
+            self._is_first_member = False
+        else:
+            self._stream.write_more()
+
+        member_name = schema.expect_member_name()
+        if self._use_json_name and (json_name := schema.get_trait(JSONNameTrait)):
+            member_name = json_name.value
+
+        self._stream.write_key(member_name)
+        return self._parent
+
+    def after(self, schema: "Schema") -> None:
+        pass
+
+
+class JSONListSerializer(InterceptingSerializer):
+    _stream: "StreamingJSONEncoder"
+    _parent: JSONShapeSerializer
+    _is_first_entry = True
+
+    def __init__(
+        self, stream: "StreamingJSONEncoder", parent: JSONShapeSerializer
+    ) -> None:
+        self._stream = stream
+        self._parent = parent
+
+    def __enter__(self) -> Self:
+        self._stream.write_array_start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        if not exc_value:
+            self._stream.write_array_end()
+
+    def before(self, schema: "Schema") -> ShapeSerializer:
+        if self._is_first_entry:
+            self._is_first_entry = False
+        else:
+            self._stream.write_more()
+
+        return self._parent
+
+    def after(self, schema: "Schema") -> None:
+        pass
+
+
+class JSONMapSerializer(MapSerializer):
+    _stream: "StreamingJSONEncoder"
+    _parent: JSONShapeSerializer
+    _is_first_entry = True
+
+    def __init__(
+        self, stream: "StreamingJSONEncoder", parent: JSONShapeSerializer
+    ) -> None:
+        self._stream = stream
+        self._parent = parent
+
+    def __enter__(self) -> Self:
+        self._stream.write_object_start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        if not exc_value:
+            self._stream.write_object_end()
+
+    def entry(self, key: str, value_writer: Callable[[ShapeSerializer], None]) -> None:
+        if self._is_first_entry:
+            self._is_first_entry = False
+        else:
+            self._stream.write_more()
+
+        self._stream.write_key(key)
+        value_writer(self._parent)
+
+
+class StreamingJSONEncoder:
+    def __init__(
+        self,
+        sink: BytesWriter,
+        default_timestamp_format: TimestampFormat = TimestampFormat.DATE_TIME,
+    ) -> None:
+        self._sink = sink
+        if isinstance(sink, RawIOBase):
+            self._sink = BufferedWriter(sink)
+        self._default_timestamp_format = default_timestamp_format
+
+    def write_object_start(self) -> None:
+        self._sink.write(b"{")
+
+    def write_object_end(self) -> None:
+        self._sink.write(b"}")
+
+    def write_array_start(self) -> None:
+        self._sink.write(b"[")
+
+    def write_array_end(self) -> None:
+        self._sink.write(b"]")
+
+    def write_key(self, key: str) -> None:
+        self.write_string(key)
+        self._sink.write(b":")
+
+    def write_more(self):
+        self._sink.write(b",")
+
+    def write_document_value(
+        self, value: DocumentValue, *, timestamp_format: TimestampFormat | None = None
+    ) -> None:
+        match value:
+            case str():
+                self.write_string(value)
+            case bool():
+                self.write_bool(value)
+            case int():
+                self.write_int(value)
+            case float() | Decimal():
+                self.write_float(value)
+            case None:
+                self.write_null()
+            case bytes():
+                self.write_string(b64encode(value).decode("utf-8"))
+            case datetime():
+                format = timestamp_format or self._default_timestamp_format
+                self.write_document_value(value=format.serialize(value))
+            case Mapping():
+                self.write_object_start()
+                first = True
+                for k, v in value.items():
+                    if not first:
+                        self.write_more()
+                    else:
+                        first = False
+                    self.write_key(k)
+                    self.write_document_value(v)
+                self.write_object_end()
+            case Sequence():
+                self.write_array_start()
+                if value:
+                    self.write_document_value(value[0])
+                    for i in range(1, len(value)):
+                        self.write_more()
+                        self.write_document_value(value[i])
+                self.write_array_end()
+
+    def write_string(self, value: str) -> None:
+        self._sink.write(b'"')
+        self._sink.write(
+            value.replace("\\", "\\\\").replace('"', '\\"').encode("utf-8")
+        )
+        self._sink.write(b'"')
+
+    def write_int(self, value: int) -> None:
+        self._sink.write(repr(value).encode("utf-8"))
+
+    def write_float(self, value: float | Decimal) -> None:
+        if not self._write_non_numeric_float(value=value):
+            if isinstance(value, Decimal):
+                self._sink.write(str(value.normalize()).encode("utf-8"))
+            else:
+                self._sink.write(repr(value).encode("utf-8"))
+
+    def _write_non_numeric_float(self, value: float | Decimal) -> bool:
+        if value != value:
+            self._sink.write(b"NaN")
+            return True
+
+        if value == _INF:
+            self._sink.write(b'"Infinity"')
+            return True
+
+        if value == _NEG_INF:
+            self._sink.write(b'"-Infinity"')
+            return True
+
+        return False
+
+    def write_bool(self, value: bool) -> None:
+        self._sink.write(b"true" if value else b"false")
+
+    def write_null(self):
+        self._sink.write(b"null")
+
+    def flush(self) -> None:
+        if isinstance(self._sink, Flushable):
+            self._sink.flush()

smithy_json-0.0.1/src/smithy_json/py.typed

@@ -0,0 +1 @@
+Marker