smithy-python 0.1.0__py3-none-any.whl

smithy_python/model/_prelude.py

@@ -0,0 +1,60 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""The embedded subset of the Smithy prelude.
+
+Only the shapes that model members and relationships can target are embedded.
+Trait-definition shapes are intentionally omitted: trait keys are not resolved
+as references, and later stages never generate or inspect trait definitions.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from types import MappingProxyType
+from typing import Any, Final
+
+_P: Final = "smithy.api#"
+
+_SIMPLE: Final = (
+    ("String", "string"),
+    ("Blob", "blob"),
+    ("BigInteger", "bigInteger"),
+    ("BigDecimal", "bigDecimal"),
+    ("Timestamp", "timestamp"),
+    ("Document", "document"),
+    ("Boolean", "boolean"),
+    ("Byte", "byte"),
+    ("Short", "short"),
+    ("Integer", "integer"),
+    ("Long", "long"),
+    ("Float", "float"),
+    ("Double", "double"),
+)
+
+_PRIMITIVE: Final = (
+    ("PrimitiveBoolean", "boolean", False),
+    ("PrimitiveByte", "byte", 0),
+    ("PrimitiveShort", "short", 0),
+    ("PrimitiveInteger", "integer", 0),
+    ("PrimitiveLong", "long", 0),
+    ("PrimitiveFloat", "float", 0),
+    ("PrimitiveDouble", "double", 0),
+)
+
+
+def prelude_ast() -> Mapping[str, Mapping[str, Any]]:
+    """Return a fresh JSON AST ``shapes`` mapping for the embedded prelude."""
+    shapes: dict[str, Mapping[str, Any]] = {}
+    for name, type_name in _SIMPLE:
+        shapes[_P + name] = {"type": type_name}
+    for name, type_name, default in _PRIMITIVE:
+        shapes[_P + name] = {
+            "type": type_name,
+            "traits": {_P + "default": default},
+        }
+    shapes[_P + "Unit"] = {
+        "type": "structure",
+        "members": {},
+        "traits": {_P + "unitType": {}},
+    }
+    return MappingProxyType(shapes)

smithy_python/model/_shape_id.py

@@ -0,0 +1,115 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Shape identifiers."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Final, Self
+
+from ..exceptions import InvalidShapeIdError
+
+_IDENTIFIER: Final = r"_*[A-Za-z][A-Za-z0-9_]*"
+_IDENTIFIER_RE: Final = re.compile(_IDENTIFIER)
+_NAMESPACE_RE: Final = re.compile(rf"{_IDENTIFIER}(?:\.{_IDENTIFIER})*")
+
+PRELUDE_NAMESPACE: Final = "smithy.api"
+
+
+@dataclass(frozen=True, slots=True)
+class ShapeId:
+    """A Smithy shape ID: ``namespace#Name`` or ``namespace#Name$member``.
+
+    Shape IDs are hashable and totally ordered by (namespace, name, member),
+    with the root shape sorting before its members.
+    """
+
+    namespace: str
+    name: str
+    member: str | None = None
+
+    def __post_init__(self) -> None:
+        if not _NAMESPACE_RE.fullmatch(self.namespace):
+            raise InvalidShapeIdError(
+                f"Invalid shape ID namespace {self.namespace!r} in {self._raw()!r}"
+            )
+        if not _IDENTIFIER_RE.fullmatch(self.name):
+            raise InvalidShapeIdError(
+                f"Invalid shape ID name {self.name!r} in {self._raw()!r}"
+            )
+        if self.member is not None and not _IDENTIFIER_RE.fullmatch(self.member):
+            raise InvalidShapeIdError(
+                f"Invalid shape ID member {self.member!r} in {self._raw()!r}"
+            )
+
+    @classmethod
+    def from_string(cls, value: str, *, default_namespace: str | None = None) -> Self:
+        """Parse an absolute or relative shape ID.
+
+        Relative IDs (no ``#``) are resolved against ``default_namespace``;
+        without one they are rejected.
+        """
+        if "#" in value:
+            namespace, _, rest = value.partition("#")
+            if "#" in rest:
+                raise InvalidShapeIdError(f"Invalid shape ID {value!r}")
+        elif default_namespace is not None:
+            namespace, rest = default_namespace, value
+        else:
+            raise InvalidShapeIdError(
+                f"Invalid shape ID {value!r}: expected an absolute shape ID "
+                "of the form namespace#Name"
+            )
+        name, sep, member = rest.partition("$")
+        try:
+            return cls(namespace, name, member if sep else None)
+        except InvalidShapeIdError:
+            raise InvalidShapeIdError(f"Invalid shape ID {value!r}") from None
+
+    @property
+    def is_member(self) -> bool:
+        """Whether this ID refers to a member."""
+        return self.member is not None
+
+    @property
+    def root(self) -> ShapeId:
+        """This ID without its member component."""
+        if self.member is None:
+            return self
+        return ShapeId(self.namespace, self.name)
+
+    def with_member(self, member: str) -> ShapeId:
+        """Return the ID of ``member`` within this shape."""
+        return ShapeId(self.namespace, self.name, member)
+
+    def __str__(self) -> str:
+        return self._raw()
+
+    def _raw(self) -> str:
+        base = f"{self.namespace}#{self.name}"
+        return base if self.member is None else f"{base}${self.member}"
+
+    def _key(self) -> tuple[str, str, bool, str]:
+        return (self.namespace, self.name, self.member is not None, self.member or "")
+
+    def __lt__(self, other: ShapeId) -> bool:
+        return self._key() < other._key()
+
+    def __le__(self, other: ShapeId) -> bool:
+        return self._key() <= other._key()
+
+    def __gt__(self, other: ShapeId) -> bool:
+        return self._key() > other._key()
+
+    def __ge__(self, other: ShapeId) -> bool:
+        return self._key() >= other._key()
+
+
+def as_shape_id(
+    value: ShapeId | str, *, default_namespace: str | None = None
+) -> ShapeId:
+    """Coerce a string or ShapeId to a ShapeId."""
+    if isinstance(value, ShapeId):
+        return value
+    return ShapeId.from_string(value, default_namespace=default_namespace)

smithy_python/model/_shapes.py

@@ -0,0 +1,251 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Shape types and the flattened, immutable shape classes."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from enum import StrEnum
+from types import MappingProxyType
+from typing import Final
+
+from ._shape_id import PRELUDE_NAMESPACE, ShapeId, as_shape_id
+
+type Node = None | bool | int | float | str | tuple[Node, ...] | Mapping[str, Node]
+"""A deeply immutable JSON value: arrays are tuples, objects read-only mappings."""
+
+type JsonValue = (
+    None | bool | int | float | str | list[JsonValue] | dict[str, JsonValue]
+)
+"""A mutable JSON value, as produced by :func:`to_json`."""
+
+
+def to_json(node: Node) -> JsonValue:
+    """Return a mutable copy of a node, e.g. for ``json.dumps`` or editing."""
+    if isinstance(node, Mapping):
+        return {k: to_json(v) for k, v in node.items()}
+    if isinstance(node, tuple):
+        return [to_json(v) for v in node]
+    return node
+
+
+class ShapeType(StrEnum):
+    """Every shape type in the Smithy 2.0 semantic model, including members."""
+
+    BLOB = "blob"
+    BOOLEAN = "boolean"
+    STRING = "string"
+    BYTE = "byte"
+    SHORT = "short"
+    INTEGER = "integer"
+    LONG = "long"
+    FLOAT = "float"
+    DOUBLE = "double"
+    BIG_INTEGER = "bigInteger"
+    BIG_DECIMAL = "bigDecimal"
+    TIMESTAMP = "timestamp"
+    DOCUMENT = "document"
+    ENUM = "enum"
+    INT_ENUM = "intEnum"
+    LIST = "list"
+    MAP = "map"
+    STRUCTURE = "structure"
+    UNION = "union"
+    MEMBER = "member"
+    SERVICE = "service"
+    RESOURCE = "resource"
+    OPERATION = "operation"
+
+
+SIMPLE_TYPES: Final = frozenset(
+    {
+        ShapeType.BLOB,
+        ShapeType.BOOLEAN,
+        ShapeType.STRING,
+        ShapeType.BYTE,
+        ShapeType.SHORT,
+        ShapeType.INTEGER,
+        ShapeType.LONG,
+        ShapeType.FLOAT,
+        ShapeType.DOUBLE,
+        ShapeType.BIG_INTEGER,
+        ShapeType.BIG_DECIMAL,
+        ShapeType.TIMESTAMP,
+        ShapeType.DOCUMENT,
+    }
+)
+
+MIXIN_TRAIT: Final = ShapeId(PRELUDE_NAMESPACE, "mixin")
+UNIT: Final = ShapeId(PRELUDE_NAMESPACE, "Unit")
+
+_EMPTY_TRAITS: Final[Mapping[ShapeId, Node]] = MappingProxyType({})
+_EMPTY_MEMBERS: Final[Mapping[str, MemberShape]] = MappingProxyType({})
+
+
+@dataclass(frozen=True, slots=True, kw_only=True, eq=False)
+class Shape:
+    """Base class of every shape.
+
+    Shapes are already mixin-flattened: ``members`` and ``traits`` include
+    everything inherited from mixins, in a deterministic order. Instances are
+    immutable; trait values are deeply frozen :data:`Node` values (use
+    :func:`to_json` for a mutable copy). Equality is identity.
+    """
+
+    id: ShapeId
+    type: ShapeType
+    traits: Mapping[ShapeId, Node] = _EMPTY_TRAITS
+    """Trait ID to JSON node value, in merge order (see the loader docs)."""
+    mixins: tuple[ShapeId, ...] = ()
+    """The mixins this shape declared, in declaration order.
+
+    Informational only: members, traits, and properties already include
+    everything inherited from these mixins.
+    """
+    members: Mapping[str, MemberShape] = _EMPTY_MEMBERS
+    """Members by name, in order: inherited mixin members, then local ones."""
+
+    def has_trait(self, trait: ShapeId | str) -> bool:
+        """Whether the shape has a trait; relative names resolve to smithy.api."""
+        return _trait_id(trait) in self.traits
+
+    def get_trait(self, trait: ShapeId | str) -> Node:
+        """Return a trait value or None if absent (use has_trait for presence)."""
+        return self.traits.get(_trait_id(trait))
+
+    @property
+    def is_mixin(self) -> bool:
+        """Whether the shape is marked with ``@mixin``."""
+        return MIXIN_TRAIT in self.traits
+
+
+def _trait_id(trait: ShapeId | str) -> ShapeId:
+    return as_shape_id(trait, default_namespace=PRELUDE_NAMESPACE)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True, eq=False)
+class SimpleShape(Shape):
+    """A blob, boolean, string, numeric, timestamp, or document shape."""
+
+
+@dataclass(frozen=True, slots=True, kw_only=True, eq=False)
+class MemberShape(Shape):
+    """A member of an aggregate shape; its ID is rooted at its container."""
+
+    type: ShapeType = ShapeType.MEMBER
+    target: ShapeId
+
+    @property
+    def container(self) -> ShapeId:
+        """ID of the shape that contains this member."""
+        return self.id.root
+
+    @property
+    def name(self) -> str:
+        """The member name."""
+        assert self.id.member is not None  # noqa: S101 - invariant
+        return self.id.member
+
+
+@dataclass(frozen=True, slots=True, kw_only=True, eq=False)
+class ListShape(Shape):
+    """A list shape; ``members`` contains exactly ``member``."""
+
+    @property
+    def member(self) -> MemberShape:
+        return self.members["member"]
+
+
+@dataclass(frozen=True, slots=True, kw_only=True, eq=False)
+class MapShape(Shape):
+    """A map shape; ``members`` contains ``key`` then ``value``."""
+
+    @property
+    def key(self) -> MemberShape:
+        return self.members["key"]
+
+    @property
+    def value(self) -> MemberShape:
+        return self.members["value"]
+
+
+@dataclass(frozen=True, slots=True, kw_only=True, eq=False)
+class StructureShape(Shape):
+    """A structure shape."""
+
+
+@dataclass(frozen=True, slots=True, kw_only=True, eq=False)
+class UnionShape(Shape):
+    """A union shape."""
+
+
+@dataclass(frozen=True, slots=True, kw_only=True, eq=False)
+class EnumShape(Shape):
+    """A string enum; member values live in ``smithy.api#enumValue``."""
+
+
+@dataclass(frozen=True, slots=True, kw_only=True, eq=False)
+class IntEnumShape(Shape):
+    """An integer enum; member values live in ``smithy.api#enumValue``."""
+
+
+@dataclass(frozen=True, slots=True, kw_only=True, eq=False)
+class ServiceShape(Shape):
+    """A service shape."""
+
+    version: str | None = None
+    operations: tuple[ShapeId, ...] = ()
+    resources: tuple[ShapeId, ...] = ()
+    errors: tuple[ShapeId, ...] = ()
+    rename: Mapping[ShapeId, str] = field(default_factory=lambda: MappingProxyType({}))
+
+
+@dataclass(frozen=True, slots=True, kw_only=True, eq=False)
+class ResourceShape(Shape):
+    """A resource shape."""
+
+    identifiers: Mapping[str, ShapeId] = field(
+        default_factory=lambda: MappingProxyType({})
+    )
+    properties: Mapping[str, ShapeId] = field(
+        default_factory=lambda: MappingProxyType({})
+    )
+    create: ShapeId | None = None
+    put: ShapeId | None = None
+    read: ShapeId | None = None
+    update: ShapeId | None = None
+    delete: ShapeId | None = None
+    list: ShapeId | None = None
+    operations: tuple[ShapeId, ...] = ()
+    collection_operations: tuple[ShapeId, ...] = ()
+    resources: tuple[ShapeId, ...] = ()
+
+
+@dataclass(frozen=True, slots=True, kw_only=True, eq=False)
+class OperationShape(Shape):
+    """An operation shape.
+
+    An absent ``input`` or ``output`` is ``smithy.api#Unit``, matching Smithy's
+    semantic model; explicit and implicit Unit are indistinguishable.
+    """
+
+    input: ShapeId = UNIT
+    output: ShapeId = UNIT
+    errors: tuple[ShapeId, ...] = ()
+
+
+SHAPE_CLASSES: Final[Mapping[ShapeType, type[Shape]]] = MappingProxyType(
+    {
+        **dict.fromkeys(SIMPLE_TYPES, SimpleShape),
+        ShapeType.LIST: ListShape,
+        ShapeType.MAP: MapShape,
+        ShapeType.STRUCTURE: StructureShape,
+        ShapeType.UNION: UnionShape,
+        ShapeType.ENUM: EnumShape,
+        ShapeType.INT_ENUM: IntEnumShape,
+        ShapeType.SERVICE: ServiceShape,
+        ShapeType.RESOURCE: ResourceShape,
+        ShapeType.OPERATION: OperationShape,
+    }
+)

smithy_python/selection.py

@@ -0,0 +1,157 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Service and data-shape selection on a loaded semantic model."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass
+
+from .exceptions import InvalidInvocationError, InvalidShapeIdError, ModelError
+from .model import (
+    MemberShape,
+    Model,
+    OperationShape,
+    ResourceShape,
+    ServiceShape,
+    Shape,
+    ShapeId,
+    ShapeType,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class Selection:
+    """Selected service and eligible data shapes in original model order."""
+
+    service: ServiceShape | None
+    shapes: tuple[Shape, ...]
+    excluded_count: int
+    """Eligible data shapes omitted by the service closure (zero without a service)."""
+
+
+def select_shapes(
+    model: Model, *, service_id: str | None = None, require_service: bool = False
+) -> Selection:
+    """Select data for generation from an already loaded, flattened model.
+
+    Service selection failures raise ``InvalidInvocationError``. Without a
+    service, case-insensitive data-shape name conflicts raise ``ModelError``.
+    This stage neither validates Smithy semantics nor writes output.
+    """
+    service = resolve_service(
+        model, service_id=service_id, require_service=require_service
+    )
+    eligible = tuple(
+        shape
+        for shape in model.iter_shapes()
+        if shape.type
+        not in (
+            ShapeType.SERVICE,
+            ShapeType.OPERATION,
+            ShapeType.RESOURCE,
+            ShapeType.MEMBER,
+        )
+        and not shape.is_mixin
+        and not shape.has_trait("trait")
+    )
+    if service is None:
+        _check_names(eligible)
+        return Selection(service=None, shapes=eligible, excluded_count=0)
+
+    visited: set[ShapeId] = set()
+    pending = [service.id]
+    while pending:
+        shape_id = pending.pop()
+        if shape_id in visited:
+            continue
+        visited.add(shape_id)
+        pending.extend(_references(model.get_shape(shape_id)))
+
+    selected = tuple(shape for shape in eligible if shape.id in visited)
+    return Selection(
+        service=service, shapes=selected, excluded_count=len(eligible) - len(selected)
+    )
+
+
+def _references(shape: Shape) -> Iterator[ShapeId]:
+    # Only semantic relationships are edges, never trait nodes, rename entries,
+    # or mixin declarations (the loader has already flattened their contents).
+    for member in shape.members.values():
+        yield member.target
+    if isinstance(shape, MemberShape):
+        yield shape.target
+    elif isinstance(shape, ServiceShape):
+        yield from shape.operations
+        yield from shape.resources
+        yield from shape.errors
+    elif isinstance(shape, OperationShape):
+        yield shape.input
+        yield shape.output
+        yield from shape.errors
+    elif isinstance(shape, ResourceShape):
+        yield from shape.identifiers.values()
+        yield from shape.properties.values()
+        for operation in (
+            shape.create,
+            shape.put,
+            shape.read,
+            shape.update,
+            shape.delete,
+            shape.list,
+        ):
+            if operation is not None:
+                yield operation
+        yield from shape.operations
+        yield from shape.collection_operations
+        yield from shape.resources
+
+
+def _check_names(shapes: tuple[Shape, ...]) -> None:
+    by_name: dict[str, list[ShapeId]] = {}
+    for shape in shapes:
+        by_name.setdefault(shape.id.name.casefold(), []).append(shape.id)
+    conflicts = [ids for ids in by_name.values() if len(ids) > 1]
+    if conflicts:
+        details = "; ".join(
+            ", ".join(str(shape_id) for shape_id in ids) for ids in conflicts
+        )
+        raise ModelError(f"Case-insensitive data shape name conflicts: {details}")
+
+
+def resolve_service(
+    model: Model, *, service_id: str | None = None, require_service: bool = False
+) -> ServiceShape | None:
+    """Resolve an absolute service ID or the sole non-mixin service.
+
+    Invalid or ambiguous selections raise :class:`InvalidInvocationError`.
+    """
+    if service_id is not None:
+        try:
+            shape_id = ShapeId.from_string(service_id)
+        except InvalidShapeIdError as error:
+            raise InvalidInvocationError(f"--service: {error}") from error
+        if shape_id.is_member:
+            raise InvalidInvocationError(
+                f"--service {service_id!r} is a member ID, not a service"
+            )
+        shape = model.find_shape(shape_id)
+        if shape is None:
+            raise InvalidInvocationError(f"--service {service_id!r} is not defined")
+        if not isinstance(shape, ServiceShape):
+            raise InvalidInvocationError(f"--service {service_id!r} is not a service")
+        if shape.is_mixin:
+            raise InvalidInvocationError(f"--service {service_id!r} is a mixin")
+        return shape
+
+    services = model.services()
+    if len(services) > 1:
+        candidates = ", ".join(str(service.id) for service in services)
+        raise InvalidInvocationError(
+            f"Multiple services found; select one with --service: {candidates}"
+        )
+    if services:
+        return services[0]
+    if require_service:
+        raise InvalidInvocationError("Client generation requires a service")
+    return None

smithy_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.5
+Name: smithy-python
+Version: 0.1.0
+Summary: A Smithy code generator for Python clients and types.
+Project-URL: Changelog, https://github.com/smithy-lang/smithy-python/blob/develop/packages/smithy-python/CHANGELOG.md
+Project-URL: Code, https://github.com/smithy-lang/smithy-python/tree/develop/packages/smithy-python/
+Project-URL: Issue tracker, https://github.com/smithy-lang/smithy-python/issues
+Author: Amazon Web Services
+License: Apache License 2.0
+License-File: NOTICE
+Keywords: codegen,sdk,smithy
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+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 :: Free Threading :: 2 - Beta
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# smithy-python
+
+> [!WARNING]
+> This package is an experimental scaffold. It does not generate code yet. The
+> Java generator in the repository's `codegen` directory remains authoritative.
+
+`smithy-python` will provide Python-native code generation for Smithy models.
+The initial command-line interface exposes the planned client and types generation
+commands so that their top-level shape can be developed independently from the
+generator implementation.
+
+```console
+smithy-python generate client [OPTIONS]
+smithy-python generate types [OPTIONS]
+```
+
+After validating their invocation options, both generation commands currently exit
+with an error explaining that generation has not been implemented. The package is
+included in workspace builds to validate its packaging and entry points.

smithy_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+smithy_python/__init__.py,sha256=TYc2ZwzNfYTsMhGUavAo7icqsC0mLg-n72wdROvgAsM,190
+smithy_python/__main__.py,sha256=k8QDgjDBeX6t-Kk934IctxdYkfSUyVpVDah4yKBaQcw,187
+smithy_python/cli.py,sha256=lcHI12FVGAN0OX5ZWzOnwLOvZAexTHV5m8pzSb1g3ds,5982
+smithy_python/environment.py,sha256=4N-E_8P_a-YNGoa0XtzQifeoSDdWdVCh-LgWn6wdkas,1359
+smithy_python/exceptions.py,sha256=2HEVrOGGymv1OyC0izM8YJq1sCKKWIovbk_UHAu2Pj8,835
+smithy_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smithy_python/selection.py,sha256=oIAn4gRN9eVN3VDjuSMXNrzUhzdb-TgSdIsrD8vOmqw,5373
+smithy_python/model/__init__.py,sha256=kq_nBh2wldOrOqsxlQQjPtqEuiJCIoodBh9laIFIs_M,1268
+smithy_python/model/_loader.py,sha256=pRUkx9mJzeHp2HecoC_aliMy3XU6AYG6c3aPCrkMV-I,21226
+smithy_python/model/_model.py,sha256=dbPvZ6ZEp8B2N6vuHifX2qLuSbhWJHIgY8avx8GQz1M,4872
+smithy_python/model/_prelude.py,sha256=UUjJ29cL5WciRFqqNh2Zj9I52TUVCyzYIuN2RIKbOok,1814
+smithy_python/model/_shape_id.py,sha256=Jky_-TwiZd1k-SKRqqqmydGfhrar8ITQxir22YoBQgw,3942
+smithy_python/model/_shapes.py,sha256=hzL0654EMxKkfOkOvd7OA6-d4JHhXz3r92XqRfoY1Mo,7603
+smithy_python-0.1.0.dist-info/METADATA,sha256=t6rpLxKqChGqOajmHP_Uz8FuysD-zDxNFSl3tJG3spE,2128
+smithy_python-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+smithy_python-0.1.0.dist-info/entry_points.txt,sha256=MbnKGy68WZXMhKsryaaGzekHxS8racdfA6mF5VS4QxI,57
+smithy_python-0.1.0.dist-info/licenses/NOTICE,sha256=1CkO1kwu3Q_OHYTj-d-yiBJA_lNN73a4zSntavaD4oc,67
+smithy_python-0.1.0.dist-info/RECORD,,

smithy_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

smithy_python-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+smithy-python = smithy_python.cli:main

smithy_python-0.1.0.dist-info/licenses/NOTICE

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