clear-skies-aws 2.0.2__py3-none-any.whl → 2.0.3__py3-none-any.whl

{clear_skies_aws-2.0.2.dist-info → clear_skies_aws-2.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clear-skies-aws
-Version: 2.0.2
+Version: 2.0.3
 Summary: clearskies bindings for working in AWS
 Project-URL: Repository, https://github.com/clearskies-py/clearskies-aws
 Project-URL: Issues, https://github.com/clearskies-py/clearskies-aws/issues
@@ -16,7 +16,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Requires-Python: <4.0,>=3.11
 Requires-Dist: boto3<2.0.0,>=1.26.148
-Requires-Dist: clear-skies<3.0.0,>=2.0.2
+Requires-Dist: clear-skies<3.0.0,>=2.0.20
 Requires-Dist: types-boto3[dynamodb,sns,sqs]<2.0.0,>=1.38.13
 Provides-Extra: akeyless
 Requires-Dist: akeyless-cloud-id<0.5.0,>=0.2.3; extra == 'akeyless'

{clear_skies_aws-2.0.2.dist-info → clear_skies_aws-2.0.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clearskies_aws/__init__.py,sha256=LAzXoPm5wVRdxUoQIWuBS_c71t9IT_iq-mIh338154o,297
+clearskies_aws/__init__.py,sha256=-vmIX17AJIxy3-2CO4iXofUcgIUAckfHfdrkHtkya8g,368
 clearskies_aws/actions/__init__.py,sha256=YsIi3ZTdByu4R7I77uOAXDE5hzB31J_tRrIoTxe_bjo,371
 clearskies_aws/actions/action_aws.py,sha256=JMogBFIrN72h5oBQLbyMy0LmfVLrqvWCYLQDml1qO4M,4674
 clearskies_aws/actions/assume_role.py,sha256=XNxbVju460aBMS8NQhY80eoNVQgZRJ6-OydsNOx3neA,4319
@@ -13,39 +13,39 @@ clearskies_aws/backends/dynamo_db_condition_parser.py,sha256=OipIlFpcfS2GQiGpge6
 clearskies_aws/backends/dynamo_db_parti_ql_backend.py,sha256=x1pLNTUsTjCxi1SDryr9_uhL-AQJS7ksP5bvQpnhaC8,46081
 clearskies_aws/backends/sqs_backend.py,sha256=kHTzgBwpYzV31UcGaoSUcC_7eZEwm-GsCHvXFM1OLT0,2152
 clearskies_aws/configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clearskies_aws/contexts/__init__.py,sha256=sdcIT85OXqwwo8CcBYuyNcN6kvkwv1Ph8MTwuSi4Bnk,767
-clearskies_aws/contexts/cli_web_socket_mock.py,sha256=ZjOhOtQHJ4Vf9V1Bkole6JiGyP1CLTzPqwTrLiiOi0A,660
-clearskies_aws/contexts/lambda_alb.py,sha256=9eLemimudZ4WsWGarONIhoiFnlk_fBygQ6XwJb7NrbY,3237
-clearskies_aws/contexts/lambda_api_gateway.py,sha256=K8sKDV2JtXbzcDy9SOd7kMveuD6t5VGxls2iDMiVhXY,2787
-clearskies_aws/contexts/lambda_api_gateway_web_socket.py,sha256=t3dLRT3s37xHazMa-KVOSWF-0OaUpGQ4an-olbeeJUw,3238
-clearskies_aws/contexts/lambda_invocation.py,sha256=j3AhSXMHRwKufOSTUjhMyeFk4sO_Y4BlX4ECCFvMudw,538
-clearskies_aws/contexts/lambda_sns.py,sha256=FFOIyyCQFKvYsolpf8zlVitdceRkgvEjds3GCXSJjdk,719
-clearskies_aws/contexts/lambda_sqs_standard_partial_batch.py,sha256=kWl3rFtsAbSkadRLZunN20oXvCQpZJFcDhv3VMMWrCg,1093
+clearskies_aws/contexts/__init__.py,sha256=kBLUlkpIp88n5RgbE9gVi4rDnJou81vCE5g_aiv2v8Y,717
+clearskies_aws/contexts/cli_web_socket_mock.py,sha256=XjsFcx0YlQqjb9Hh8q2NUW7T2Exu7_FHx9v_Am0Uq0g,784
+clearskies_aws/contexts/lambda_alb.py,sha256=hNMWYePN_moC4waXdydAp7dJkGpSowxDZZzU39Sxc7I,3426
+clearskies_aws/contexts/lambda_api_gateway.py,sha256=HWH-CAX_aYiDhQr8rBhR5TW99-wx2ODsyI_dqGJkcdw,3354
+clearskies_aws/contexts/lambda_api_gateway_web_socket.py,sha256=gO0arcveIbvkCxrqjk8piVwcymuw_pgHwsSfdfElyWU,4583
+clearskies_aws/contexts/lambda_invoke.py,sha256=Ouns3zIw0G1aCuB0yVS91PgNqFVyqT3Oe6NcDgaEcvY,4872
+clearskies_aws/contexts/lambda_sns.py,sha256=_TyPqRWosfaJzreYGNabvR-XTLYYO4eVWMVINSIY-OE,4129
+clearskies_aws/contexts/lambda_sqs_standard.py,sha256=uzENeXJaWsZoUxves8IXo8wFrcub_viQSKF9fmmPPvE,5293
 clearskies_aws/di/__init__.py,sha256=pLHSIKxS1oELOgttRuwM0yXdJRxjZKXQ6tPxme2db0U,222
 clearskies_aws/di/aws_additional_config_auto_import.py,sha256=qc9AUlFdF9jhAzS99esyvgY1MiW7mLz45fATK7Yp0rg,1271
 clearskies_aws/di/inject/__init__.py,sha256=5_x5_BBQwC6J4k5YLdTm1DfIDM-95zXz1L5a1nMrlrY,186
 clearskies_aws/di/inject/boto3.py,sha256=7qcn5N-RnUKiCd1U31JAjQHF6NDudS4KyBLT0krUD-Y,404
 clearskies_aws/di/inject/boto3_session.py,sha256=11UYHz5kgrrx5lawoYaOFBm-QIoa45YUCMAOn4gT8Jo,383
 clearskies_aws/di/inject/parameter_store.py,sha256=g0uAVwQEywLO9bCcYLbDKuyYnYgVyrfcYsOBJWYGads,475
-clearskies_aws/endpoints/__init__.py,sha256=A2e3zCI8Ywg95WcTk1f92fpmlJ6eD4mTfcR43yX9sow,112
-clearskies_aws/endpoints/secrets_manager_rotation.py,sha256=CqtE7pJ1FiPStRjMI1WsflcYXgcr-miRUE-IU1UKmnk,7764
+clearskies_aws/endpoints/__init__.py,sha256=OUL_nhtuNs62BvQeVtC9xP_e9Hs_-qjANvb81vdLdrc,61
+clearskies_aws/endpoints/secrets_manager_rotation.py,sha256=wLJjid_K09rXGEd_MIgoHP84im4_Eo2m_lwAxn36Jf8,7763
 clearskies_aws/endpoints/simple_body_routing.py,sha256=B3fnfxUEMuNpzc26Pzly6618DFU9fpaCk8KhTGSaptE,1181
-clearskies_aws/input_outputs/__init__.py,sha256=83rhCp7knun2WB4Pd53H8KvVgM_4_Lt0YuD2Gvo2UPk,755
-clearskies_aws/input_outputs/cli_web_socket_mock.py,sha256=a96M1vnUfpe0YL04iSFpV_oXG6IkygRd710CDo72wc4,496
+clearskies_aws/input_outputs/__init__.py,sha256=RTDFwhPWZ2S0tZQiIPH0Tkj2xF-9qBjZte_CA2cmGt8,743
+clearskies_aws/input_outputs/cli_web_socket_mock.py,sha256=cp0MaJjVnsXE1rx5K44lpN9uHKo3MOAsNxVQ3AsJOi4,547
 clearskies_aws/input_outputs/lambda_alb.py,sha256=iYooG5AlkrQQgzSt304A5_u_UhuqYh-9PeLvFdGM_Eg,2013
 clearskies_aws/input_outputs/lambda_api_gateway.py,sha256=n5XiaxmaFKJ9wMQcNQwizpjcA-L_bdLk1aUk-QyO58w,4672
-clearskies_aws/input_outputs/lambda_api_gateway_web_socket.py,sha256=P9cMrOxRlezUh7OIqGrV_34amksI6n_1ZPYujSLY_so,2702
-clearskies_aws/input_outputs/lambda_input_output.py,sha256=71sW2vQi-yCf0wE8DGso0Zy1G7cn5D-gnEELIvEnbiw,2743
-clearskies_aws/input_outputs/lambda_invocation.py,sha256=y8dPkjt9rvSJd2tkctdtM1-q_SnRPR_bXc9aySjRgdE,2800
-clearskies_aws/input_outputs/lambda_sns.py,sha256=n04gS8bgo3sX8EZTkBvdCykm5dlV4lloc7IoPv71_T8,2657
-clearskies_aws/input_outputs/lambda_sqs_standard.py,sha256=ubrSdU0RTHIURLk_kgKs3Gt7LcxaUlRBdA67169qHlA,2880
+clearskies_aws/input_outputs/lambda_api_gateway_web_socket.py,sha256=B7LIXI_9HpquTtUuPVnb7aH1agJt9qTWiISWiNlobdo,2926
+clearskies_aws/input_outputs/lambda_input_output.py,sha256=nJza0TFdAYOHdLvq6eFDW-TobpeF3EzuIsW9rdhrj3U,2819
+clearskies_aws/input_outputs/lambda_invoke.py,sha256=9TvtxVn2MYxUq9luZ-o0DMboFulA5ff-G8RFo3_x-nA,2861
+clearskies_aws/input_outputs/lambda_sns.py,sha256=nPvLxi5EUmgSeDYxFHnosG9mEzVKjt_mOFJvjsb1gQ4,3084
+clearskies_aws/input_outputs/lambda_sqs_standard.py,sha256=rtOH75SKuT4ByOn4tfgDvvLog0IZVaZUh8zQ_E4Yygw,2945
 clearskies_aws/mocks/__init__.py,sha256=mn764gINN667tYoJfnsM6HjAAhCsO_kZ6E-fUwdLY50,22
 clearskies_aws/mocks/actions/__init__.py,sha256=to1r8B365Et2PRVfUWWnJGt7Hdr8vwwQuNyZvTSTP6g,152
 clearskies_aws/mocks/actions/ses.py,sha256=KsII9ggU364BQoxgHfO2rxi6tjVsdnwJyMhtclOhWLQ,998
 clearskies_aws/mocks/actions/sns.py,sha256=yGY3V0_htOZ3y8VTLdznoMSUQZvnjulQbrR5z_-0fXQ,706
 clearskies_aws/mocks/actions/sqs.py,sha256=y0Vq7IMbjlfT5JMNHfbPsq9XVZhUF-G0kdXzQnPzyUA,710
 clearskies_aws/mocks/actions/step_function.py,sha256=ENEVy8Ai3vPymbQre5aWa5z2McBjlnopfsLxdO7oEbc,937
-clearskies_aws/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+clearskies_aws/models/__init__.py,sha256=tAU5cPGRSzSClNVRCBxzwlBq6eZO8fftuI3bG1jEyVQ,87
 clearskies_aws/models/web_socket_connection_model.py,sha256=5M1qfQHKuWMYPUDkwT48QPo2ROey7koizvWLfapsfow,7492
 clearskies_aws/secrets/__init__.py,sha256=0mqYja2ETBHJh4b3jgRhhJV1uGdZc9S7cUvcV5QByPs,445
 clearskies_aws/secrets/akeyless_with_ssm_cache.py,sha256=32HUS1KQ5F6Fu70HDtojqDL7VZvP_YDgbWLTTmNJvPA,2073
@@ -57,7 +57,7 @@ clearskies_aws/secrets/additional_configs/iam_db_auth.py,sha256=PwyiLaacpRfhBKzQ
 clearskies_aws/secrets/additional_configs/iam_db_auth_with_ssm.py,sha256=ABY29X-YvrE6vvNo6kVdf4DqyRNq5cFR5SfK7MNkltE,3463
 clearskies_aws/secrets/additional_configs/mysql_connection_dynamic_producer_via_ssh_cert_bastion.py,sha256=mLaplwvJLSbGh6oXgdOKL9Mv-6hLv5OUYCfEwHbHvLE,3700
 clearskies_aws/secrets/additional_configs/mysql_connection_dynamic_producer_via_ssm_bastion.py,sha256=2VHOwto4I9gBwrpd2HGpL-Wr0T2S-jFjUhe2Ib8hNJ8,6596
-clear_skies_aws-2.0.2.dist-info/METADATA,sha256=BcwJmkUhC-KD2QwepuW2kAeU6IRITpMOKrKCgAO2_b4,8972
-clear_skies_aws-2.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-clear_skies_aws-2.0.2.dist-info/licenses/LICENSE,sha256=MkEX8JF8kZxdyBpTTcB0YTd-xZpWnHvbRlw-pQh8u58,1069
-clear_skies_aws-2.0.2.dist-info/RECORD,,
+clear_skies_aws-2.0.3.dist-info/METADATA,sha256=ZQj_x9m1wlgaf4SH_gu1AJiGiykQzDjdnBRLOgh9Q1Y,8973
+clear_skies_aws-2.0.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+clear_skies_aws-2.0.3.dist-info/licenses/LICENSE,sha256=MkEX8JF8kZxdyBpTTcB0YTd-xZpWnHvbRlw-pQh8u58,1069
+clear_skies_aws-2.0.3.dist-info/RECORD,,

{clear_skies_aws-2.0.2.dist-info → clear_skies_aws-2.0.3.dist-info}/WHEEL

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

clearskies_aws/__init__.py

@@ -1,15 +1,27 @@
 from __future__ import annotations
 
-from clearskies_aws import actions, backends, contexts, di, endpoints, input_outputs, mocks, models, secrets
+from clearskies_aws import (
+    actions,
+    backends,
+    contexts,
+    di,
+    endpoints,
+    handlers,
+    input_outputs,
+    mocks,
+    models,
+    secrets,
+)
 
 __all__ = [
-    "models",
     "actions",
     "backends",
     "contexts",
     "di",
     "endpoints",
+    "handlers",
     "input_outputs",
     "mocks",
+    "models",
     "secrets",
 ]

clearskies_aws/contexts/__init__.py

@@ -6,10 +6,10 @@ from clearskies_aws.contexts.lambda_api_gateway import LambdaApiGateway
 from clearskies_aws.contexts.lambda_api_gateway_web_socket import (
     LambdaApiGatewayWebSocket,
 )
-from clearskies_aws.contexts.lambda_invocation import LambdaInvocation
+from clearskies_aws.contexts.lambda_invoke import LambdaInvoke
 from clearskies_aws.contexts.lambda_sns import LambdaSns
-from clearskies_aws.contexts.lambda_sqs_standard_partial_batch import (
-    LambdaSqsStandardPartialBatch,
+from clearskies_aws.contexts.lambda_sqs_standard import (
+    LambdaSqsStandard,
 )
 
 __all__ = [
@@ -17,7 +17,7 @@ __all__ = [
     "LambdaAlb",
     "LambdaApiGateway",
     "LambdaApiGatewayWebSocket",
-    "LambdaInvocation",
+    "LambdaInvoke",
     "LambdaSns",
-    "LambdaSqsStandardPartialBatch",
+    "LambdaSqsStandard",
 ]

clearskies_aws/contexts/cli_web_socket_mock.py

@@ -12,8 +12,9 @@ class CliWebSocketMock(cli.Cli):
     The LambdaApiGatewayWebSocket context makes it easy to run websocket applications, but testing
     these locally is literally impossible.  This context provides a close analogue to the way
     the LambdaApiGatewayWebSocket context works to give some testing capabilities when running
-    locally.
+    locally.  It works identically to `clearskies.contexts.Cli` but you have to provide a
+    `connection_id` property in the JSON body.
     """
 
     def __call__(self):
-        return self.execute_application(CliWebSocketMockInputOutput())
+        return self.execute_application(CLIWebSocketMockInputOutput())

clearskies_aws/contexts/lambda_alb.py

@@ -65,11 +65,16 @@ class LambdaAlb(Context):
         return application(event, context)
     ```
 
-    ### Context for Callables
+    ### Context Specifics
 
     When using this context, two additional named arguments become available to any callables invoked by clearskies:
-    `event` and `context`.  These correspond to the original `event` and `context` variables provided by AWS to
-    the lambda.
+
+    ```
+    |      Name     |       Type       | Description                      |
+    |:-------------:|:----------------:|----------------------------------|
+    |    `event`    | `dict[str, Any]` | The lambda `event` object        |
+    |   `context`   | `dict[str, Any]` | The lambda `context` object      |
+    ```
     """
 
     def __call__(self, event: dict[str, Any], context: dict[str, Any]) -> Any:  # type: ignore[override]

clearskies_aws/contexts/lambda_api_gateway.py

@@ -59,19 +59,23 @@ class LambdaApiGateway(Context):
         return application(event, context)
     ```
 
-    ### Context for Callables
+    ### Context Specifics
 
     When using this context, a number of additional named arguments become available to any callables invoked by
     clearskies:
 
-     1. `event`
-     2. `context`
-     3. `resource`
-     4. `stage`
-     5. `request_id`
-     6. `api_id`
-     7. `api_version` (v1 or v2)
+    ```
+    |      Name     |       Type       | Description                      |
+    |:-------------:|:----------------:|----------------------------------|
+    |   ` event`    | `dict[str, Any]` | The lambda `event` object        |
+    |   `context`   | `dict[str, Any]` | The lambda `context` object      |
+    |   `resource`  |       `str`      | The route resource               |
+    |    `stage`    |       `str`      | The stage of the lambda function |
+    |  `request_id` |       `str`      | The AWS request id for the call  |
+    |    `api_id`   |       `str`      | The id of the API                |
+    | `api_version` |       `str`      | "v1" or "v2"                     |
+    ```
     """
 
-    def __call__(self, event: dict[str, Any], context: dict[str, Any]) -> Any:  # type: ignore[override]
+    def __call__(self, event: dict[str, Any], context: dict[str, Any]) -> dict[str, Any]:  # type: ignore[override]
         return self.execute_application(LambdaApiGatewayInputOutput(event, context))

clearskies_aws/contexts/lambda_api_gateway_web_socket.py

@@ -37,7 +37,7 @@ class LambdaApiGatewayWebSocket(Context):
     having to handle such things themselves, since the typical standards of web frameworks won't match up.  In
     the case of routing with an API Gateway, it has its own suggested standard of setting a routekey where the
     API gateway will check for an application-defined route parameter in the request body and use this to route
-    to an appropriate lambda.  With clearskies, you can also use the `clearskies.endpoints.JsonParamEndpointGroup`
+    to an appropriate lambda.  With clearskies, you can also use the `clearskies.endpoints.BodyParameterRouting`
     to accomplish the same.
 
     With a websocket through API Gateway, headers are available during the `on_connect` phase, so you can always
@@ -51,7 +51,29 @@ class LambdaApiGatewayWebSocket(Context):
     there is a base model class in `clearskies_aws.models.WebSocketConnectionModel`.  Check the documentation for
     this class to understand how this is managed and see a "starter" websocket application.
 
+    ### Context Specifics
+
+    The following parameters are made available by name to any function invoked by clearskies when using
+    this context:
+
+    ```
+    |       Name      |       Type       | Description                                      |
+    |:---------------:|:----------------:|--------------------------------------------------|
+    |     `event`     | `dict[str, Any]` | The lambda `event` object                        |
+    |    `context`    | `dict[str, Any]` | The lambda `context` object                      |
+    | `connection_id` |       `str`      | The Connection ID                                |
+    |   `route_key`   |       `str`      | The value of the route key, as determined by AWS |
+    |     `stage`     |       `str`      | The stage of the lambda function                 |
+    |   `request_id`  |       `str`      | The AWS request id for the call                  |
+    |     `api_id`    |       `str`      | The id of the API                                |
+    |  `domain_name`  |       `str`      | The domain name                                  |
+    |   `event_type`  |       `str`      | One of "MESSAGE", "CONNECT", or "DISCONNECT"     |
+    |  `connected_at` |       `str`      | The connection time                              |
+    ```
+
     """
 
-    def __call__(self, event: dict[str, Any], context: dict[str, Any], url: str = "") -> Any:  # type: ignore[override]
+    def __call__(
+        self, event: dict[str, Any], context: dict[str, Any], url: str = "", request_method: str = ""
+    ) -> dict[str, Any]:  # type: ignore[override]
         return self.execute_application(LambdaApiGatewayWebSocketInputOutput(event, context, url))

clearskies_aws/contexts/lambda_invoke.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from typing import Any
+
+from clearskies.authentication import Public
+from clearskies.contexts.context import Context
+
+from clearskies_aws.input_outputs import LambdaInvoke as LambdaInvokeInputOutput
+
+
+class LambdaInvoke(Context):
+    """
+    Execute a lambda directly.
+
+    This context is used when your clearskies application is running in a lambda that is executed
+    directly by some variation of `aws lambda invoke`.  For this context, the `event` object passed
+    to the lambda handler becomes the request body in the clearskies application.  Note that, unlike
+    other lambda execution strategies (ALB, Api Gateway, etc...) the event object is exactly equal
+    to the body sent in with the lambda function.
+
+    ### Usage
+
+    Here's a simple example:
+
+    ```
+    import clearskies
+
+
+    def my_function(request_data):
+        return request_data
+
+
+    lambda_invoke = clearskies_aws.contexts.LambdaInvoke(
+        clearskies.endpoints.Callable(
+            my_function,
+            return_standard_response=False,
+        )
+    )
+
+
+    def lambda_handler(event, context):
+        return lambda_invoke(event, context)
+    ```
+
+    You can attach this to a lambda and might invoke it like so, with the following response:
+
+    ```
+    $ aws lambda invoke --function-name [function_name] --cli-binary-format raw-in-base64-out --payload '{"some":"data"}' | jq
+    { "Payload": {"some": "data"} }
+    ```
+
+    Invoking a lambda doesn't happen from an http context, so there is no URL/request method/headers/etc.
+    This typically means that clearskies applications in this context don't do routing and don't have
+    authentication configured.  If you wanted to though, you could use `clearskies.endpoints.BodyParameterRouting`
+    to setup some basic routing and let the invoking client choose a route by providing a parameter in the
+    payload passed to lambda invoke.
+
+    You can pass a URL/request method into the context when you invoke it, which is often used to simplify
+    configuration: you can setup a standard clearskies applications with multiple endpoints, and then
+    use that one application in multiple lambdas, specifying which endpoint to call for each lambda.
+    This can also be helpful if you already have a clearskies application prepared for a standard http context
+    and want to execute some subset of those endpoints in a lambda invoke context.  It looks something like this:
+
+    ```
+    import clearskies
+
+
+    def some_function(request_data):
+        return request_data
+
+
+    def some_other_function(request_data):
+        return request_data
+
+
+    def something_else(request_data):
+        return request_data
+
+
+    lambda_invoke = clearskies_aws.contexts.LambdaInvoke(
+        clearskies.endpoints.EndpointGroup(
+            [
+                clearskies.endpoints.Callable(
+                    some_function,
+                    url="some_function",
+                ),
+                clearskies.endpoints.Callable(
+                    some_other_function,
+                    url="some_other_function",
+                ),
+                clearskies.endpoints.Callable(
+                    something_else,
+                    url="something_else",
+                ),
+            ]
+        )
+    )
+
+
+    def some_function_handler(event, context):
+        return lambda_invoke(event, context, url="some_function")
+
+
+    def some_other_function_handler(event, context):
+        return lambda_invoke(event, context, url="some_other_function")
+
+
+    def something_else_handler(event, context):
+        return lambda_invoke(event, context, url="something_else")
+    ```
+
+    ### Context Specifics
+
+    When using the lambda_invoke context, it exposes a few context specific parameters which can be injected into
+    any function called by clearskies:
+
+    |       Name         |        Type      |           Description           |
+    |:------------------:|:----------------:|:-------------------------------:|
+    |       `event`      | `dict[str, Any]` | The lambda `event` object       |
+    |      `context`     | `dict[str, Any]` | The lambda `context` object     |
+    |  `invocation_type` |      `str`       |        Always `"direct"`        |
+    |   `function_name`  |      `str`       | The name of the lambda function |
+    | `function_version` |      `str`       |       The function version      |
+    |    `request_id`    |      `str`       | The AWS request id for the call |
+
+    """
+
+    def __call__(
+        self, event: dict[str, Any], context: dict[str, Any], request_method: str = "", url: str = ""
+    ) -> dict[str, Any]:  # type: ignore[override]
+        return self.execute_application(
+            LambdaInvokeInputOutput(
+                event,
+                context,
+                request_method=request_method,
+                url=url,
+            )
+        )

clearskies_aws/contexts/lambda_sns.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Any
+
 from clearskies.authentication import Public
 from clearskies.contexts.context import Context
 
@@ -7,12 +9,116 @@ from clearskies_aws.input_outputs import LambdaSns as LambdaSnsInputOutput
 
 
 class LambdaSns(Context):
-    def __call__(self, event, context, method=None, url=None):
-        if self.execute_application is None:
-            raise ValueError("Cannot execute LambdaSnsEvent context without first configuring it")
+    """
+    Execute a clearskies application when attached to a lambda triggered by SNS.
+
+    This one is very straight-forward: just attach your clearskies application to work with an
+    SNS-triggered lambda.  `request_data` provided to the clearskies application will be the
+    message sent to the SNS.  Since this is no longer an http context, the various http parameters
+    (url, request method, headers, and even responses) do not exist.  Routing won't exist unless
+    you use `clearskies.endpoints.BodyParameterRouting` and include the route parameter in your
+    SNS message body.
+
+    ### Usage
+
+    Here's a simple example:
+
+    ```
+    import clearskies
+
+
+    def my_function(request_data):
+        print(request_data)
+
+
+    lambda_invoke = clearskies_aws.contexts.LambdaInvoke(
+        clearskies.endpoints.Callable(
+            my_function,
+            return_standard_response=False,
+        )
+    )
+
+
+    def lambda_handler(event, context):
+        return lambda_invoke(event, context)
+    ```
+
+    Note the lack of a return value.  You can return a value if you want, but it will be ignored
+    because SNS has no concept of a return response.
+
+    If you have a number of Lambda/SNS handlers, you can bundle them together for ease-of-management
+    and specify the URL when you invoke them:
+
+    ```
+    import clearskies
+
+
+    def some_function(request_data):
+        return request_data
+
+
+    def some_other_function(request_data):
+        return request_data
+
+
+    def something_else(request_data):
+        return request_data
+
+
+    lambda_invoke = clearskies_aws.contexts.LambdaSns(
+        clearskies.endpoints.EndpointGroup(
+            [
+                clearskies.endpoints.Callable(
+                    some_function,
+                    url="some_function",
+                ),
+                clearskies.endpoints.Callable(
+                    some_other_function,
+                    url="some_other_function",
+                ),
+                clearskies.endpoints.Callable(
+                    something_else,
+                    url="something_else",
+                ),
+            ]
+        )
+    )
+
+
+    def some_function_handler(event, context):
+        return lambda_invoke(event, context, url="some_function")
+
+
+    def some_other_function_handler(event, context):
+        return lambda_invoke(event, context, url="some_other_function")
+
+
+    def something_else_handler(event, context):
+        return lambda_invoke(event, context, url="something_else")
+    ```
+
+    ### Context Specifics
+
+    When you use the LambdaSns context, it makes the following named parameters available
+    to any callable that is invoked by clearskies:
+
+    ```
+    |    Name      |      Type        | Description                                    |
+    |:------------:|:----------------:|------------------------------------------------|
+    |    `event`   | `dict[str, Any]` | The lambda `event` object                      |
+    |   `context`  | `dict[str, Any]` | The lambda `context` object                    |
+    | `message_id` |       `str`      | The AWS message id                             |
+    |  `topic_arn` |       `str`      | The ARN of the SNS topic that sent the message |
+    |   `subject`  |       `str`      | Any subject attached to the SNS message        |
+    |  `timestamp` |       `str`      | The timestamp when the message was sent        |
+    ```
+    """
 
+    def __call__(self, event: dict[str, Any], context: dict[str, Any], request_method: str = "", url: str = ""):  # type: ignore[override]
         try:
-            return self.execute_application(LambdaSnsInputOutput(event, context, method=method, url=url))
+            return self.execute_application(
+                LambdaSnsInputOutput(event, context, request_method=request_method, url=url)
+            )
         except Exception as e:
             print("Failed message " + event["Records"][0]["Sns"]["MessageId"] + ". Error error: " + str(e))
             raise e

clearskies_aws/contexts/lambda_sqs_standard.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import traceback
+from typing import Any
+
+from clearskies.authentication import Public
+from clearskies.contexts.context import Context
+
+from clearskies_aws.input_outputs import LambdaSqsStandard as LambdaSqsStandardInputOutput
+
+
+class LambdaSqsStandard(Context):
+    """
+    Process messages from an SQS Standard Queue with Lambda.
+
+    Use this context when your application lives in a Lambda and is attached to an SQS standard
+    queue.  Lambda always uses batch processing in this case, and will invoke your clearskies application
+    with a batch of messags.  This clearskies context will then in turn invoke your application once
+    for every batched message.  As a result, `request_data` will contain the contents of an individual message
+    from the queue, rather than the original group of batched events from Lambda.  If any exception is thrown,
+    every other message in the queue will still be sent to your application, and clearskies will inform
+    AWS that the message and question failed to process.
+
+    ### Usage
+
+    Here's a very simple example:
+
+    ```
+    import clearskies
+
+
+    def some_function(request_data):
+        return print(request_data)
+
+
+    lambda_sqs = clearskies_aws.contexts.LambdaSqsStandard(
+        clearskies.endpoints.Callable(
+            some_function,
+        ),
+    )
+
+
+    def lambda_handler(event, context):
+        return lambda_sqs(event, context)
+    ```
+
+    `lambda_handler` would then be attached to your lambda function, which is attached to some standard SQS.
+
+    Like the other lambda contexts which don't exist in an HTTP world, you can also attach a clearskies application
+    with routing and hard-code the path to invoke inside the lambda handler itself.  This is handy if you have
+    a few related lambdas with similar configuration (since you only have to build a single application) or if
+    you have an application that already exists and you want to invoke some specific endpoint with an SQS:
+
+    ```
+    import clearskies
+
+
+    def some_function(request_data):
+        return request_data
+
+
+    def some_other_function(request_data):
+        return request_data
+
+
+    def something_else(request_data):
+        return request_data
+
+
+    lambda_invoke = clearskies_aws.contexts.LambdaSqsStandard(
+        clearskies.endpoints.EndpointGroup(
+            [
+                clearskies.endpoints.Callable(
+                    some_function,
+                    url="some_function",
+                ),
+                clearskies.endpoints.Callable(
+                    some_other_function,
+                    url="some_other_function",
+                ),
+                clearskies.endpoints.Callable(
+                    something_else,
+                    url="something_else",
+                ),
+            ]
+        )
+    )
+
+
+    def some_function_handler(event, context):
+        return lambda_invoke(event, context, url="some_function")
+
+
+    def some_other_function_handler(event, context):
+        return lambda_invoke(event, context, url="some_other_function")
+
+
+    def something_else_handler(event, context):
+        return lambda_invoke(event, context, url="something_else")
+    ```
+
+    ### Context Specifics
+
+    When using this context, the following named parameters become available to inject into any callable
+    invoked by clearskies:
+
+    ```
+    |             Name            |       Type       | Description                                            |
+    |:---------------------------:|:----------------:|--------------------------------------------------------|
+    |           `event`           | `dict[str, Any]` | The lambda `event` object                              |
+    |          `context`          | `dict[str, Any]` | The lambda `context` object                            |
+    |         `message_id`        |       `str`      | The AWS message id                                     |
+    |       `receipt_handle`      |       `str`      | The receipt handle                                     |
+    |         `source_arn`        |       `str`      | The ARN of the SQS the lambda is receiving events from |
+    |       `sent_timestamp`      |       `str`      | The timestamp when the message was sent                |
+    | `approximate_receive_count` |       `str`      | The approximate receive count                          |
+    |     `message_attributes`    | `dict[str, Any]` | The message attributes                                 |
+    |           `record`          | `dict[str, Any]` | The full record of the message being processed         |
+    ```
+
+    """
+
+    def __call__(
+        self, event: dict[str, Any], context: dict[str, Any], url: str = "", request_method: str = ""
+    ) -> dict[str, Any]:  # type: ignore[override]
+        item_failures = []
+        for record in event["Records"]:
+            try:
+                self.execute_application(
+                    LambdaSqsStandardInputOutput(record, event, context, url=url, request_method=request_method)
+                )
+            except Exception as e:
+                item_failures.append({"itemIdentifier": record["messageId"]})
+
+        if item_failures:
+            return {
+                "batchItemFailures": item_failures,
+            }
+        return {}

clearskies_aws/endpoints/__init__.py

@@ -1,2 +1 @@
 from .secrets_manager_rotation import SecretsManagerRotation
-from .simple_body_routing import SimpleBodyRouting

clearskies_aws/endpoints/secrets_manager_rotation.py

@@ -19,7 +19,6 @@ from clearskies_aws.di import inject
 
 
 class SecretsManagerRotation(Endpoint):
-
     di = Di()
     boto3 = inject.Boto3()
 

clearskies_aws/input_outputs/__init__.py

@@ -6,7 +6,7 @@ from clearskies_aws.input_outputs.lambda_api_gateway import LambdaApiGateway
 from clearskies_aws.input_outputs.lambda_api_gateway_web_socket import (
     LambdaApiGatewayWebSocket,
 )
-from clearskies_aws.input_outputs.lambda_invocation import LambdaInvocation
+from clearskies_aws.input_outputs.lambda_invoke import LambdaInvoke
 from clearskies_aws.input_outputs.lambda_sns import LambdaSns
 from clearskies_aws.input_outputs.lambda_sqs_standard import LambdaSqsStandard
 
@@ -15,7 +15,7 @@ __all__ = [
     "LambdaApiGateway",
     "LambdaApiGatewayWebSocket",
     "LambdaAlb",
-    "LambdaInvocation",
+    "LambdaInvoke",
     "LambdaSns",
     "LambdaSqsStandard",
 ]

clearskies_aws/input_outputs/cli_web_socket_mock.py

@@ -15,4 +15,6 @@ class CliWebSocketMock(clearskies.input_outputs.Cli):
             "event": {},
             "context": {},
             "connection_id": connection_id,
+            "domain": "",
+            "stage": "",
         }

clearskies_aws/input_outputs/lambda_api_gateway_web_socket.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from typing import Any
 
 from clearskies.configs import String
@@ -24,7 +25,7 @@ class LambdaApiGatewayWebSocket(lambda_input_output.LambdaInputOutput):
         request_context = event.get("requestContext", {})
 
         # WebSocket uses route_key, but doesn't have either a route or a method
-        self.route_key = request_context.get("routeKey", "")
+        self.route_key = request_context.get("routeKey", "GET")
         self.request_method = self.route_key.upper()  # For compatibility
 
         # WebSocket connection ID
@@ -47,12 +48,13 @@ class LambdaApiGatewayWebSocket(lambda_input_output.LambdaInputOutput):
 
         raise ValueError("Unable to find the client ip inside the API Gateway")
 
-    def respond(self, body: Any, status_code: int = 200) -> dict[str, Any]:
-        """Create WebSocket specific response format."""
-        # WebSocket responses are simpler than HTTP responses
-        return {
-            "statusCode": status_code,
-        }
+    def respond(self, body: Any, status_code: int = 200) -> None:
+        # since there is no response to the client, we want to raise an exception for any non-200 status code so
+        # the lambda execution itself will be marked as a failure.
+        if status_code > 299:
+            if not isinstance(body, str):
+                body = json.dumps(body)
+            raise Exception(f"Non-200 Status code returned by application: {status_code}.  Response: '{body}'")
 
     def context_specifics(self) -> dict[str, Any]:
         """Provide WebSocket specific context data."""

clearskies_aws/input_outputs/lambda_input_output.py

@@ -20,7 +20,9 @@ class LambdaInputOutput(InputOutput):
     _cached_body = None
     _body_was_cached = False
 
-    def __init__(self, event: dict[str, Any], context: dict[str, Any]):
+    def __init__(
+        self, event: dict[str, Any], context: dict[str, Any], url: str | None = "", request_method: str | None = ""
+    ):
         # Store event and context
         self.event = event
         self.context = context
@@ -28,7 +30,7 @@ class LambdaInputOutput(InputOutput):
         # Initialize the base class
         super().__init__()
 
-    def respond(self, body: Any, status_code: int = 200) -> dict[str, Any]:
+    def respond(self, body: Any, status_code: int = 200) -> dict[str, Any] | None:
         """Create standard Lambda HTTP response format."""
         if "content-type" not in self.response_headers:
             self.response_headers.content_type = "application/json; charset=UTF-8"

clearskies_aws/input_outputs/{lambda_invocation.py → lambda_invoke.py}

@@ -9,25 +9,28 @@ from clearskies.input_outputs import Headers
 from clearskies_aws.input_outputs import lambda_input_output
 
 
-class LambdaInvocation(lambda_input_output.LambdaInputOutput):
+class LambdaInvoke(lambda_input_output.LambdaInputOutput):
     """Direct Lambda invocation specific input/output handler."""
 
     def __init__(
         self,
         event: dict[str, Any],
         context: dict[str, Any],
-        method: str = "POST",
+        request_method: str = "",
         url: str = "",
     ):
         # Call parent constructor
         super().__init__(event, context)
 
         # Direct invocation specific initialization
-        self.path = url
-        self.request_method = method.upper()
-
-        # Direct invocations don't have query parameters or path parameters
-        self.query_parameters = {}
+        if url:
+            self.path = url
+        else:
+            self.supports_url = True
+        if request_method:
+            self.request_method = request_method.upper()
+        else:
+            self.supports_request_method = False
 
         # Direct invocations don't have headers
         self.request_headers = Headers({})

clearskies_aws/input_outputs/lambda_sns.py

@@ -12,16 +12,21 @@ from clearskies_aws.input_outputs import lambda_input_output
 class LambdaSns(lambda_input_output.LambdaInputOutput):
     """SNS specific Lambda input/output handler."""
 
-    def __init__(self, event: dict, context: dict[str, Any], url: str = "", method: str = "POST"):
+    record: dict[str, Any]
+
+    def __init__(self, event: dict, context: dict[str, Any], url: str = "", request_method: str = ""):
         # Call parent constructor
         super().__init__(event, context)
 
         # SNS specific initialization
-        self.path = url
-        self.request_method = method.upper()
-
-        # SNS events don't have query parameters or path parameters
-        self.query_parameters = {}
+        if url:
+            self.path = url
+        else:
+            self.supports_url = False
+        if request_method:
+            self.request_method = request_method.upper()
+        else:
+            self.supports_request_method = False
 
         # SNS events don't have headers
         self.request_headers = Headers({})
@@ -29,24 +34,29 @@ class LambdaSns(lambda_input_output.LambdaInputOutput):
         # Extract SNS message from event
         try:
             record = event["Records"][0]["Sns"]["Message"]
-            self._record = json.loads(record)
+            self.record = json.loads(record)
         except (KeyError, IndexError, json.JSONDecodeError) as e:
             raise ClientError(
                 "The message from AWS was not a valid SNS event with serialized JSON. "
                 "The lambda_sns context for clearskies only accepts serialized JSON."
             )
 
-    def respond(self, body: Any, status_code: int = 200) -> dict[str, Any]:
-        """SNS events don't return responses."""
-        return {}
+    def respond(self, body: Any, status_code: int = 200) -> None:
+        """Respond to the client, but SNS has no client."""
+        # since there is no response to the client, we want to raise an exception for any non-200 status code so
+        # the lambda execution itself will be marked as a failure.
+        if status_code > 299:
+            if not isinstance(body, str):
+                body = json.dumps(body)
+            raise Exception(f"Non-200 Status code returned by application: {status_code}.  Response: '{body}'")
 
     def get_body(self) -> str:
         """Get the SNS message as a JSON string."""
-        return json.dumps(self._record) if self._record else ""
+        return json.dumps(self.record) if self.record else ""
 
     def has_body(self) -> bool:
         """Check if SNS message exists."""
-        return bool(self._record)
+        return bool(self.record)
 
     def get_client_ip(self) -> str:
         """SNS events don't have client IP information."""
@@ -66,14 +76,13 @@ class LambdaSns(lambda_input_output.LambdaInputOutput):
 
         return {
             **super().context_specifics(),
-            "sns_message_id": sns_record.get("MessageId"),
-            "sns_topic_arn": sns_record.get("TopicArn"),
-            "sns_subject": sns_record.get("Subject"),
-            "sns_timestamp": sns_record.get("Timestamp"),
-            "sns_message": self._record,
+            "message_id": sns_record.get("MessageId"),
+            "topic_arn": sns_record.get("TopicArn"),
+            "subject": sns_record.get("Subject"),
+            "timestamp": sns_record.get("Timestamp"),
         }
 
     @property
     def request_data(self) -> dict[str, Any] | list[Any] | None:
         """Return the SNS message data directly."""
-        return self._record
+        return self.record

clearskies_aws/input_outputs/lambda_sqs_standard.py

@@ -17,31 +17,44 @@ class LambdaSqsStandard(lambda_input_output.LambdaInputOutput):
     path = String(default="/")
 
     def __init__(
-        self, record: str, event: dict[str, Any], context: dict[str, Any], url: str = "", method: str = "POST"
+        self,
+        record: dict[str, Any],
+        event: dict[str, Any],
+        context: dict[str, Any],
+        url: str = "",
+        request_method: str = "",
     ):
         # Call parent constructor with the full event
         super().__init__(event, context)
 
         # Store the individual SQS record
-        self.record = json.loads(record)
-        print("SQS record:", self.record)
+        self.record = record
         # SQS specific initialization
-        self.path = url if url else "/"
-        self.request_method = method.upper() if method else "POST"
+        if url:
+            self.path = url
+        else:
+            self.supports_url = False
 
-        # SQS events don't have query parameters or path parameters
-        self.query_parameters = {}
+        if request_method:
+            self.request_method = request_method.upper()
+        else:
+            self.supports_request_method = False
 
         # SQS events don't have headers
         self.request_headers = Headers({})
 
-    def respond(self, body: Any, status_code: int = 200) -> dict[str, Any]:
-        """SQS events don't return responses."""
-        return {}
+    def respond(self, body: Any, status_code: int = 200) -> None:
+        """Respond to the client, but SQS has no client."""
+        # since there is no response to the client, we want to raise an exception for any non-200 status code so
+        # the lambda execution itself will be marked as a failure.
+        if status_code > 299:
+            if not isinstance(body, str):
+                body = json.dumps(body)
+            raise Exception(f"Non-200 Status code returned by application: {status_code}.  Response: '{body}'")
 
     def get_body(self) -> str:
-        """Get the SQS message body."""
-        return json.dumps(self.record)
+        """Get request body with base64 decoding if needed."""
+        return self.record["body"]
 
     def has_body(self) -> bool:
         """Check if SQS message has a body."""
@@ -63,22 +76,11 @@ class LambdaSqsStandard(lambda_input_output.LambdaInputOutput):
         """Provide SQS specific context data."""
         return {
             **super().context_specifics(),
-            "sqs_message_id": self.record.get("messageId"),
-            "sqs_receipt_handle": self.record.get("receiptHandle"),
-            "sqs_source_arn": self.record.get("eventSourceARN"),
-            "sqs_sent_timestamp": self.record.get("attributes", {}).get("SentTimestamp"),
-            "sqs_approximate_receive_count": self.record.get("attributes", {}).get("ApproximateReceiveCount"),
-            "sqs_message_attributes": self.record.get("messageAttributes", {}),
-            "sqs_record": self.record,
+            "message_id": self.record.get("messageId"),
+            "receipt_handle": self.record.get("receiptHandle"),
+            "source_arn": self.record.get("eventSourceARN"),
+            "sent_timestamp": self.record.get("attributes", {}).get("SentTimestamp"),
+            "approximate_receive_count": self.record.get("attributes", {}).get("ApproximateReceiveCount"),
+            "message_attributes": self.record.get("messageAttributes", {}),
+            "record": self.record,
         }
-
-    @property
-    def request_data(self) -> dict[str, Any]:
-        """Return the SQS message body as parsed JSON."""
-        body = self.get_body()
-        if not body:
-            return {}
-        try:
-            return json.loads(body)
-        except json.JSONDecodeError:
-            raise ClientError("SQS message body was not valid JSON")

clearskies_aws/models/__init__.py

@@ -0,0 +1 @@
+from clearskies_aws.models.web_socket_connection_model import WebSocketConnectionModel

clearskies_aws/contexts/lambda_invocation.py

@@ -1,19 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from clearskies.authentication import Public
-from clearskies.contexts.context import Context
-
-from clearskies_aws.input_outputs import LambdaInvocation as LambdaInvocationInputOutput
-
-
-class LambdaInvocation(Context):
-
-    def __call__(self, event: dict[str, Any], context: dict[str, Any]) -> Any:  # type: ignore[override]
-        return self.execute_application(
-            LambdaInvocationInputOutput(
-                event,
-                context,
-            )
-        )

clearskies_aws/contexts/lambda_sqs_standard_partial_batch.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-import traceback
-
-from clearskies.authentication import Public
-from clearskies.contexts.context import Context
-
-from clearskies_aws.input_outputs import LambdaSqsStandard as LambdaSqsStandardInputOutput
-
-
-class LambdaSqsStandardPartialBatch(Context):
-    def __call__(self, event, context, url="", method="POST"):
-        item_failures = []
-        for record in event["Records"]:
-            print("Processing message " + record["messageId"], record["body"])
-            try:
-                self.execute_application(
-                    LambdaSqsStandardInputOutput(record["body"], event, context, url=url, method=method)
-                )
-            except Exception as e:
-                print("Failed message " + record["messageId"] + " being returned for retry.  Error error: " + str(e))
-                traceback.print_tb(e.__traceback__)
-                item_failures.append({"itemIdentifier": record["messageId"]})
-
-        if item_failures:
-            return {
-                "batchItemFailures": item_failures,
-            }
-        return {}