Replace Exception suffix with Error

PEP8 prefers that we have "Error" as the suffix for errors, which
makes sense in a world where exceptions are regularly used for
control flow.

Author: JordonPhillips

codegen/core/src/main/java/software/amazon/smithy/python/codegen/ClientGenerator.java

@@ -140,7 +140,6 @@ private void generateOperationExecutor(PythonWriter writer) {
         writer.addStdlibImport("dataclasses", "replace");
 
         writer.addDependency(SmithyPythonDependency.SMITHY_CORE);
-        writer.addImport("smithy_core.exceptions", "SmithyRetryException");
         writer.addImports("smithy_core.interceptors",
                 Set.of("Interceptor",
                         "InterceptorChain",
@@ -259,7 +258,7 @@ private void generateOperationExecutor(PythonWriter writer) {
         }
         writer.addStdlibImport("typing", "Any");
         writer.addStdlibImport("asyncio", "iscoroutine");
-        writer.addImports("smithy_core.exceptions", Set.of("SmithyException", "CallException"));
+        writer.addImports("smithy_core.exceptions", Set.of("SmithyError", "CallError", "RetryError"));
         writer.pushState();
         writer.putContext("request", transportRequest);
         writer.putContext("response", transportResponse);
@@ -284,10 +283,10 @@ private void generateOperationExecutor(PythonWriter writer) {
                                     request_future, response_future,
                                 )
                             except Exception as e:
-                                # Make sure every exception that we throw is an instance of SmithyException so
+                                # Make sure every exception that we throw is an instance of SmithyError so
                                 # customers can reliably catch everything we throw.
-                                if not isinstance(e, SmithyException):
-                                    wrapped = CallException(str(e))
+                                if not isinstance(e, SmithyError):
+                                    wrapped = CallError(str(e))
                                     wrapped.__cause__ = e
                                     e = wrapped
 
@@ -385,7 +384,7 @@ private void generateOperationExecutor(PythonWriter writer) {
                                                 token_to_renew=retry_token,
                                                 error=output_context.response,
                                             )
-                                        except SmithyRetryException:
+                                        except RetryError:
                                             raise output_context.response
                                         logger.debug(
                                             "Retry needed. Attempting request #%s in %.4f seconds.",

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

@@ -29,9 +29,9 @@ public void run() {
         var serviceError = CodegenUtils.getServiceError(settings);
         writers.useFileWriter(serviceError.getDefinitionFile(), serviceError.getNamespace(), writer -> {
             writer.addDependency(SmithyPythonDependency.SMITHY_CORE);
-            writer.addImport("smithy_core.exceptions", "ModeledException");
+            writer.addImport("smithy_core.exceptions", "ModeledError");
             writer.write("""
-                    class $L(ModeledException):
+                    class $L(ModeledError):
                         ""\"Base error for all errors in the service.
 
                         Some exceptions do not extend from this class, including

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

@@ -104,7 +104,7 @@ def deserialize(cls, deserializer: ShapeDeserializer) -> Self:
         // realistic implementation.
         var unknownSymbol = symbolProvider.toSymbol(shape).expectProperty(SymbolProperties.UNION_UNKNOWN);
         writer.pushState(new UnionMemberSection(unknownSymbol));
-        writer.addImport("smithy_core.exceptions", "SmithyException");
+        writer.addImport("smithy_core.exceptions", "SerializationError");
         writer.write("""
                 @dataclass
                 class $1L:
@@ -119,10 +119,10 @@ class $1L:
                     tag: str
 
                     def serialize(self, serializer: ShapeSerializer):
-                        raise SmithyException("Unknown union variants may not be serialized.")
+                        raise SerializationError("Unknown union variants may not be serialized.")
 
                     def serialize_members(self, serializer: ShapeSerializer):
-                        raise SmithyException("Unknown union variants may not be serialized.")
+                        raise SerializationError("Unknown union variants may not be serialized.")
 
                     @classmethod
                     def deserialize(cls, deserializer: ShapeDeserializer) -> Self:
@@ -147,7 +147,7 @@ private void generateDeserializer() {
         writer.addLogger();
         writer.addStdlibImports("typing", Set.of("Self", "Any"));
         writer.addImport("smithy_core.deserializers", "ShapeDeserializer");
-        writer.addImport("smithy_core.exceptions", "SmithyException");
+        writer.addImport("smithy_core.exceptions", "SerializationError");
 
         // TODO: add in unknown handling
 
@@ -164,7 +164,7 @@ def deserialize(self, deserializer: ShapeDeserializer) -> $2T:
                         deserializer.read_struct($3T, self._consumer)
 
                         if self._result is None:
-                            raise SmithyException("Unions must have exactly one value, but found none.")
+                            raise SerializationError("Unions must have exactly one value, but found none.")
 
                         return self._result
 
@@ -176,7 +176,7 @@ def _consumer(self, schema: Schema, de: ShapeDeserializer) -> None:
 
                     def _set_result(self, value: $2T) -> None:
                         if self._result is not None:
-                            raise SmithyException("Unions must have exactly one value, but found more than one.")
+                            raise SerializationError("Unions must have exactly one value, but found more than one.")
                         self._result = value
                 """,
                 deserializerSymbol.getName(),

codegen/core/src/main/java/software/amazon/smithy/python/codegen/integrations/HttpProtocolGeneratorUtils.java

@@ -139,18 +139,18 @@ public static void generateErrorDispatcher(
         var canReadResponseBody = canReadResponseBody(operation, context.model());
         delegator.useFileWriter(errorDispatcher.getDefinitionFile(), errorDispatcher.getNamespace(), writer -> {
             writer.pushState(new ErrorDispatcherSection(operation, errorShapeToCode, errorMessageCodeGenerator));
-            writer.addImport("smithy_core.exceptions", "CallException");
+            writer.addImport("smithy_core.exceptions", "CallError");
             // TODO: include standard retry-after in the pure-python version of this
             writer.write("""
-                    async def $1L(http_response: $2T, config: $3T) -> CallException:
+                    async def $1L(http_response: $2T, config: $3T) -> CallError:
                         ${4C|}
 
                         match code.lower():
                             ${5C|}
 
                             case _:
                                 is_throttle = http_response.status == 429
-                                return CallException(
+                                return CallError(
                                     message=f"{code}: {message}",
                                     fault="client" if http_response.status < 500 else "server",
                                     is_throttling_error=is_throttle,

designs/exceptions.md

@@ -14,21 +14,20 @@ smithy-python clients will expose exceptions to customers.
 
 ## Specification
 
-Every exception raised by a Smithy client MUST inherit from `SmithyException`.
+Every exception raised by a Smithy client MUST inherit from `SmithyError`.
 
 ```python
-class SmithyException(Exception):
+class SmithyError(Exception):
     """Base exception type for all exceptions raised by smithy-python."""
 ```
 
-If an exception that is not a `SmithyException` is thrown while executing a
-request, that exception MUST be wrapped in a `SmithyException` and the
-`__cause__` MUST be set to the original exception.
+If an exception that is not a `SmithyError` is thrown while executing a request,
+that exception MUST be wrapped in a `SmithyError` and the `__cause__` MUST be
+set to the original exception.
 
 Just as in normal Python programming, different exception types SHOULD be made
-for different kinds of exceptions. `SerializationException`, for example, will
-serve as the exception type for any exceptions that occur while serializing a
-request.
+for different kinds of exceptions. `SerializationError`, for example, will serve
+as the exception type for any exceptions that occur while serializing a request.
 
 ### Retryability
 
@@ -42,7 +41,7 @@ implement.
 @runtime_checkable
 class ErrorRetryInfo(Protocol):
     is_retry_safe: bool | None = None
-    """Whether the exception is safe to retry.
+    """Whether the error is safe to retry.
 
     A value of True does not mean a retry will occur, but rather that a retry is allowed
     to occur.
@@ -61,16 +60,15 @@ class ErrorRetryInfo(Protocol):
     """Whether the error is a throttling error."""
 ```
 
-If an exception with `RetryInfo` is received while attempting to send a
+If an exception with `ErrorRetryInfo` is received while attempting to send a
 serialized request to the server, the contained information will be used to
 inform the next retry.
 
-### Service Exceptions
+### Service Errors
 
-Exceptions returned by the service MUST be a `CallException`. `CallException`s
-include a `fault` property that indicates whether the client or server is
-responsible for the exception. HTTP protocols can determine this based on the
-status code.
+Errors returned by the service MUST be a `CallError`. `CallError`s include a
+`fault` property that indicates whether the client or server is responsible for
+the exception. HTTP protocols can determine this based on the status code.
 
 Similarly, protocols can and should determine retry information. HTTP protocols
 can generally be confident that a status code 429 is a throttling error and can
@@ -86,21 +84,21 @@ If None, then there was not enough information to determine fault.
 
 
 @dataclass(kw_only=True)
-class CallException(SmithyException, RetryInfo):
+class CallError(SmithyError, ErrorRetryInfo):
     fault: Fault = None
     message: str = field(default="", kw_only=False)
 ```
 
-#### Modeled Exceptions
+#### Modeled Errors
 
 Most exceptions thrown by a service will be present in the Smithy model for the
 service. These exceptions will all be generated into the client package. Each
 modeled exception will be inherit from a generated exception named
-`ServiceException` which itself inherits from the static `ModeledException`.
+`ServiceError` which itself inherits from the static `ModeledError`.
 
 ```python
 @dataclass(kw_only=True)
-class ModeledException(CallException):
+class ModeledError(CallError):
     """Base exception to be used for modeled errors."""
 ```
 
@@ -112,13 +110,13 @@ This information will be statically generated onto the exception.
 
 ```python
 @dataclass(kw_only=True)
-class ServiceException(ModeledException):
+class ServiceError(ModeledError):
     pass
 
 
 @dataclass(kw_only=True)
-class ThrottlingException(ServcieException):
-    fault: Fault = "client"
+class ThrottlingError(ServiceError):
+    fault: Fault = "server"
     is_retry_safe: bool | None = True
     is_throttling_error: bool = True
 ```

packages/smithy-aws-core/src/smithy_aws_core/auth/sigv4.py

@@ -5,7 +5,7 @@
 
 from aws_sdk_signers import AsyncSigV4Signer, SigV4SigningProperties
 from smithy_core.aio.interfaces.identity import IdentityResolver
-from smithy_core.exceptions import SmithyIdentityException
+from smithy_core.exceptions import SmithyIdentityError
 from smithy_core.interfaces.identity import IdentityProperties
 from smithy_http.aio.interfaces.auth import HTTPAuthScheme, HTTPSigner
 
@@ -47,7 +47,7 @@ def identity_resolver(
         self, *, config: SigV4Config
     ) -> IdentityResolver[AWSCredentialsIdentity, IdentityProperties]:
         if not config.aws_credentials_identity_resolver:
-            raise SmithyIdentityException(
+            raise SmithyIdentityError(
                 "Attempted to use SigV4 auth, but aws_credentials_identity_resolver was not "
                 "set on the config."
             )

packages/smithy-aws-core/src/smithy_aws_core/credentials_resolvers/environment.py

@@ -3,7 +3,7 @@
 import os
 
 from smithy_core.aio.interfaces.identity import IdentityResolver
-from smithy_core.exceptions import SmithyIdentityException
+from smithy_core.exceptions import SmithyIdentityError
 from smithy_core.interfaces.identity import IdentityProperties
 
 from ..identity import AWSCredentialsIdentity
@@ -29,7 +29,7 @@ async def get_identity(
         account_id = os.getenv("AWS_ACCOUNT_ID")
 
         if access_key_id is None or secret_access_key is None:
-            raise SmithyIdentityException(
+            raise SmithyIdentityError(
                 "AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY are required"
             )
 

packages/smithy-aws-core/src/smithy_aws_core/credentials_resolvers/imds.py

@@ -9,7 +9,7 @@
 
 from smithy_core import URI
 from smithy_core.aio.interfaces.identity import IdentityResolver
-from smithy_core.exceptions import SmithyIdentityException
+from smithy_core.exceptions import SmithyIdentityError
 from smithy_core.interfaces.identity import IdentityProperties
 from smithy_core.interfaces.retries import RetryStrategy
 from smithy_core.retries import SimpleRetryStrategy
@@ -223,9 +223,7 @@ async def get_identity(
             expiration = datetime.fromisoformat(expiration).replace(tzinfo=UTC)
 
         if access_key_id is None or secret_access_key is None:
-            raise SmithyIdentityException(
-                "AccessKeyId and SecretAccessKey are required"
-            )
+            raise SmithyIdentityError("AccessKeyId and SecretAccessKey are required")
 
         self._credentials = AWSCredentialsIdentity(
             access_key_id=access_key_id,

packages/smithy-aws-core/tests/unit/credentials_resolvers/test_environment_credentials_resolver.py

@@ -3,12 +3,12 @@
 
 import pytest
 from smithy_aws_core.credentials_resolvers import EnvironmentCredentialsResolver
-from smithy_core.exceptions import SmithyIdentityException
+from smithy_core.exceptions import SmithyIdentityError
 from smithy_core.interfaces.identity import IdentityProperties
 
 
 async def test_no_values_set():
-    with pytest.raises(SmithyIdentityException):
+    with pytest.raises(SmithyIdentityError):
         await EnvironmentCredentialsResolver().get_identity(
             identity_properties=IdentityProperties()
         )
@@ -17,7 +17,7 @@ async def test_no_values_set():
 async def test_required_values_missing(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setenv("AWS_ACCOUNT_ID", "123456789012")
 
-    with pytest.raises(SmithyIdentityException):
+    with pytest.raises(SmithyIdentityError):
         await EnvironmentCredentialsResolver().get_identity(
             identity_properties=IdentityProperties()
         )
@@ -26,7 +26,7 @@ async def test_required_values_missing(monkeypatch: pytest.MonkeyPatch):
 async def test_akid_missing(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "secret")
 
-    with pytest.raises(SmithyIdentityException):
+    with pytest.raises(SmithyIdentityError):
         await EnvironmentCredentialsResolver().get_identity(
             identity_properties=IdentityProperties()
         )
@@ -35,7 +35,7 @@ async def test_akid_missing(monkeypatch: pytest.MonkeyPatch):
 async def test_secret_missing(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setenv("AWS_ACCESS_KEY_ID", "akid")
 
-    with pytest.raises(SmithyIdentityException):
+    with pytest.raises(SmithyIdentityError):
         await EnvironmentCredentialsResolver().get_identity(
             identity_properties=IdentityProperties()
         )

packages/smithy-aws-event-stream/src/smithy_aws_event_stream/aio/__init__.py

@@ -9,7 +9,7 @@
 from smithy_core.aio.interfaces.eventstream import EventPublisher, EventReceiver
 from smithy_core.codecs import Codec
 from smithy_core.deserializers import DeserializeableShape, ShapeDeserializer
-from smithy_core.exceptions import ExpectationNotMetException
+from smithy_core.exceptions import ExpectationNotMetError
 from smithy_core.serializers import SerializeableShape
 
 from .._private.deserializers import EventDeserializer as _EventDeserializer
@@ -53,7 +53,7 @@ async def send(self, event: E) -> None:
         event.serialize(self._serializer)
         result = self._serializer.get_result()
         if result is None:
-            raise ExpectationNotMetException(
+            raise ExpectationNotMetError(
                 "Expected an event message to be serialized, but was None."
             )
         if self._signer is not None: