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

clearskies_aws/input_outputs/lambda_api_gateway_web_socket.py

@@ -1,8 +1,71 @@
-from .lambda_api_gateway import LambdaAPIGateway
-class LambdaAPIGatewayWebSocket(LambdaAPIGateway):
-    def context_specifics(self):
+from __future__ import annotations
+
+from typing import Any
+
+from clearskies.configs import String
+from clearskies.input_outputs import Headers
+
+from clearskies_aws.input_outputs import lambda_input_output
+
+
+class LambdaApiGatewayWebSocket(lambda_input_output.LambdaInputOutput):
+    """Api Gateway WebSocket specific Lambda input/output handler."""
+
+    route_key = String(default="")
+    connection_id = String(default="")
+
+    def __init__(self, event: dict[str, Any], context: dict[str, Any], url: str = ""):
+        # Call parent constructor
+        super().__init__(event, context)
+
+        self.path = url
+
+        # WebSocket specific initialization
+        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.request_method = self.route_key.upper()  # For compatibility
+
+        # WebSocket connection ID
+        self.connection_id = request_context.get("connectionId", "")
+
+        # These will only be available, at monst, during the on-connect step
+        self.query_parameters = event.get("queryStringParameters") or {}
+        headers_dict = {}
+        for key, value in event.get("headers", {}).items():
+            headers_dict[key.lower()] = str(value)
+        self.request_headers = Headers(headers_dict)
+
+    def get_client_ip(self) -> str:
+        """Get the client IP address from WebSocket request context."""
+        request_context = self.event.get("requestContext", {})
+        identity = request_context.get("identity", {})
+
+        if "sourceIp" in identity:
+            return identity["sourceIp"]
+
+        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 {
-            "event": self._event,
-            "context": self._context,
-            "connection_id": self._event["requestContext"]["connectionId"],
+            "statusCode": status_code,
+        }
+
+    def context_specifics(self) -> dict[str, Any]:
+        """Provide WebSocket specific context data."""
+        request_context = self.event.get("requestContext", {})
+
+        return {
+            **super().context_specifics(),
+            "connection_id": self.connection_id,
+            "route_key": self.route_key,
+            "stage": request_context.get("stage"),
+            "request_id": request_context.get("requestId"),
+            "api_id": request_context.get("apiId"),
+            "domain_name": request_context.get("domainName"),
+            "event_type": request_context.get("eventType"),
+            "connected_at": request_context.get("connectedAt"),
         }

clearskies_aws/input_outputs/lambda_input_output.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import base64
+import json
+from abc import abstractmethod
+from typing import Any, cast
+from urllib.parse import urlencode
+
+from clearskies.configs import AnyDict, String
+from clearskies.input_outputs import InputOutput
+
+
+class LambdaInputOutput(InputOutput):
+    """Base class for Lambda input/output handlers that provides common Lambda functionality."""
+
+    event = AnyDict(default={})
+    context = AnyDict(default={})
+    path = String(default="/")
+
+    _cached_body = None
+    _body_was_cached = False
+
+    def __init__(self, event: dict[str, Any], context: dict[str, Any]):
+        # Store event and context
+        self.event = event
+        self.context = context
+
+        # Initialize the base class
+        super().__init__()
+
+    def respond(self, body: Any, status_code: int = 200) -> dict[str, Any]:
+        """Create standard Lambda HTTP response format."""
+        if "content-type" not in self.response_headers:
+            self.response_headers.content_type = "application/json; charset=UTF-8"
+
+        is_base64 = False
+
+        if isinstance(body, bytes):
+            is_base64 = True
+            final_body = base64.encodebytes(body).decode("utf8")
+        elif isinstance(body, str):
+            final_body = body
+        else:
+            final_body = json.dumps(body)
+
+        return {
+            "isBase64Encoded": is_base64,
+            "statusCode": status_code,
+            "headers": dict(self.response_headers),
+            "body": final_body,
+        }
+
+    def has_body(self) -> bool:
+        return bool(self.get_body())
+
+    def get_body(self) -> str:
+        """Get request body with base64 decoding if needed."""
+        if not self._body_was_cached:
+            self._body_was_cached = True
+            self._cached_body = self.event.get("body", "")
+            if (
+                self._cached_body is not None
+                and self.event.get("isBase64Encoded", False)
+                and isinstance(self._cached_body, str)
+            ):
+                self._cached_body = base64.decodebytes(self._cached_body.encode("utf-8")).decode("utf-8")
+        return self._cached_body or ""
+
+    def get_client_ip(self) -> str:
+        """Get client IP - can be overridden by subclasses for event-specific logic."""
+        return "127.0.0.1"
+
+    def get_protocol(self) -> str:
+        """Get protocol."""
+        # Default to HTTPS for most Lambda HTTP events
+        return "https"
+
+    def get_full_path(self) -> str:
+        """Get full path."""
+        return self.path
+
+    def context_specifics(self) -> dict[str, Any]:
+        """Provide Lambda-specific context."""
+        return {
+            "event": self.event,
+            "context": self.context,
+        }

clearskies_aws/input_outputs/lambda_invocation.py

@@ -1,34 +1,85 @@
-from .lambda_api_gateway import LambdaAPIGateway
+from __future__ import annotations
+
 import json
-from clearskies.handlers.exceptions import ClientError
-class LambdaInvocation(LambdaAPIGateway):
+from typing import Any
+
+from clearskies.exceptions import ClientError
+from clearskies.input_outputs import Headers
+
+from clearskies_aws.input_outputs import lambda_input_output
+
+
+class LambdaInvocation(lambda_input_output.LambdaInputOutput):
+    """Direct Lambda invocation specific input/output handler."""
+
     def __init__(
         self,
-        event,
-        context,
-        method=None,
-        url=None,
+        event: dict[str, Any],
+        context: dict[str, Any],
+        method: str = "POST",
+        url: str = "",
     ):
-        self._event = event
-        self._context = context
-        self._path = url if url else ''
-        self._request_method = method.upper() if method else 'GET'
-        self._query_parameters = {}
-        self._path_parameters = []
-        self._request_headers = {}
-
-    def has_body(self):
+        # 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 = {}
+
+        # Direct invocations don't have headers
+        self.request_headers = Headers({})
+
+    def has_body(self) -> bool:
+        """Direct invocations always have a body (the event itself)."""
         return True
 
-    def get_body(self):
-        return self._event
+    def get_body(self) -> str:
+        """Get the entire event as the body."""
+        if isinstance(self.event, (dict, list)):
+            return json.dumps(self.event)
+        return str(self.event)
 
-    def json_body(self, required=True, allow_non_json_bodies=False):
-        # we ignore the allow_non_json_bodies flag here because with the way invoking lambdas works,
-        # the event already is an object, so it's a moot point.
-        if required and not self._event:
-            raise ClientError("Request body was not valid JSON")
-        return self._event
+    def respond(self, body: Any, status_code: int = 200) -> Any:
+        """Return the response directly for direct invocations."""
+        if isinstance(body, bytes):
+            return body.decode("utf-8")
+        return body
+
+    def get_client_ip(self) -> str:
+        """Direct invocations don't have client IP information."""
+        return "127.0.0.1"
+
+    def get_protocol(self) -> str:
+        """Direct invocations don't have a protocol."""
+        return "lambda"
 
-    def respond(self, body, status_code=200):
-        return body.decode('utf-8') if type(body) == bytes else body
+    def get_full_path(self) -> str:
+        """Return the configured path."""
+        return self.path
+
+    def context_specifics(self) -> dict[str, Any]:
+        """Provide direct invocation specific context data."""
+        return {
+            **super().context_specifics(),
+            "invocation_type": "direct",
+            "function_name": self.context.get("function_name"),
+            "function_version": self.context.get("function_version"),
+            "request_id": self.context.get("aws_request_id"),
+        }
+
+    @property
+    def request_data(self) -> dict[str, Any] | list[Any] | None:
+        """Return the event directly as request data."""
+        return self.event
+
+    def json_body(
+        self, required: bool = True, allow_non_json_bodies: bool = False
+    ) -> dict[str, Any] | list[Any] | None:
+        """Get the event as JSON data."""
+        # For direct invocations, the event is already an object, not a JSON string
+        if required and not self.event:
+            raise ClientError("Request body was not valid JSON")
+        return self.event

clearskies_aws/input_outputs/lambda_sns.py

@@ -1,52 +1,79 @@
-from .lambda_api_gateway import LambdaAPIGateway
-from clearskies.handlers.exceptions import ClientError
+from __future__ import annotations
+
 import json
-class LambdaSns(LambdaAPIGateway):
-    def __init__(self, event, context, url=None, method=None):
-        self._event = event
-        self._context = context
-        self._path = url if url else ''
-        self._request_method = method.upper() if method else 'GET'
-        record = event['Records'][0]['Sns']['Message']
-        try:
-            self._record = json.loads(record)
-        except json.JSONDecodeError as e:
-            raise ClientError("The message from AWS was not a serialized JSON string.  The lambda_sns context for clearskies only accepts serialized JSON")
+from typing import Any
 
-    def respond(self, body, status_code=200):
-        pass
+from clearskies.exceptions import ClientError
+from clearskies.input_outputs import Headers
 
-    def get_body(self):
-        return self._record
+from clearskies_aws.input_outputs import lambda_input_output
 
-    def request_data(self, required=True, allow_non_json_bodies=False):
-        return self.json_body(required=required, allow_non_json_bodies=allow_non_json_bodies)
 
-    def json_body(self, required=True, allow_non_json_bodies=False):
-        if not self._record:
-            if required:
-                raise ClientError("No SNS message found")
-            return {}
+class LambdaSns(lambda_input_output.LambdaInputOutput):
+    """SNS specific Lambda input/output handler."""
 
-        return self._record
+    def __init__(self, event: dict, context: dict[str, Any], url: str = "", method: str = "POST"):
+        # 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 = {}
 
-    def get_query_string(self):
-        raise NotImplementedError("The query string doesn't exist in an SNS context")
+        # SNS events don't have headers
+        self.request_headers = Headers({})
 
-    def get_content_type(self):
-        raise NotImplementedError("Content type doesn't exist in an SNS context")
+        # Extract SNS message from event
+        try:
+            record = event["Records"][0]["Sns"]["Message"]
+            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 get_body(self) -> str:
+        """Get the SNS message as a JSON string."""
+        return json.dumps(self._record) if self._record else ""
 
-    def get_protocol(self):
-        raise NotImplementedError("A request protocol is not defined in an SNS context")
+    def has_body(self) -> bool:
+        """Check if SNS message exists."""
+        return bool(self._record)
 
-    def has_request_header(self, header_name):
-        raise NotImplementedError("SNS contexts don't have request headers")
+    def get_client_ip(self) -> str:
+        """SNS events don't have client IP information."""
+        return "127.0.0.1"
 
-    def get_request_header(self, header_name, silent=True):
-        raise NotImplementedError("SNS contexts don't have request headers")
+    def get_protocol(self) -> str:
+        """SNS events don't have a protocol."""
+        return "sns"
 
-    def get_query_parameter(self, key):
-        raise NotImplementedError("SNS contexts don't have query parameters")
+    def get_full_path(self) -> str:
+        """Return the configured path."""
+        return self.path
 
-    def get_query_parameters(self):
-        raise NotImplementedError("SNS contexts don't have query parameters")
+    def context_specifics(self) -> dict[str, Any]:
+        """Provide SNS specific context data."""
+        sns_record = self.event.get("Records", [{}])[0].get("Sns", {})
+
+        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,
+        }
+
+    @property
+    def request_data(self) -> dict[str, Any] | list[Any] | None:
+        """Return the SNS message data directly."""
+        return self._record

clearskies_aws/input_outputs/lambda_sqs_standard.py

@@ -1,54 +1,84 @@
-from .lambda_api_gateway import LambdaAPIGateway
-from clearskies.handlers.exceptions import ClientError
+from __future__ import annotations
+
 import json
-class LambdaSqsStandard(LambdaAPIGateway):
-    def __init__(self, record, event, context, url=None, method=None):
-        self._record = record
-        self._context = context
-        self._event = event
-        self._path = url if url else ''
-        self._request_method = method.upper() if method else 'GET'
+from typing import Any
 
-    def respond(self, body, status_code=200):
-        pass
+from clearskies.configs import AnyDict, String
+from clearskies.exceptions import ClientError
+from clearskies.input_outputs import Headers
 
-    def get_body(self):
-        return self._record
+from clearskies_aws.input_outputs import lambda_input_output
 
-    def has_body(self):
-        return True
 
-    def request_data(self, required=True, allow_non_json_bodies=False):
-        return self.json_body(required=required, allow_non_json_bodies=allow_non_json_bodies)
+class LambdaSqsStandard(lambda_input_output.LambdaInputOutput):
+    """SQS standard queue specific Lambda input/output handler."""
 
-    def json_body(self, required=True, allow_non_json_bodies=False):
-        if not self._record:
-            if required:
-                raise ClientError("SQS message was not valid JSON")
-            return {}
+    record = AnyDict(default={})
+    path = String(default="/")
 
-        try:
-            return json.loads(self._record)
-        except json.JSONDecodeError:
-            raise ClientError("SQS message was not valid JSON")
+    def __init__(
+        self, record: str, event: dict[str, Any], context: dict[str, Any], url: str = "", method: str = "POST"
+    ):
+        # 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)
+        # SQS specific initialization
+        self.path = url if url else "/"
+        self.request_method = method.upper() if method else "POST"
 
-    def get_query_string(self):
-        raise NotImplementedError("The query string doesn't exist in an SQS context")
+        # SQS events don't have query parameters or path parameters
+        self.query_parameters = {}
 
-    def get_content_type(self):
-        raise NotImplementedError("Content type doesn't exist in an SQS context")
+        # SQS events don't have headers
+        self.request_headers = Headers({})
 
-    def get_protocol(self):
-        raise NotImplementedError("A request protocol is not defined in an SQS context")
+    def respond(self, body: Any, status_code: int = 200) -> dict[str, Any]:
+        """SQS events don't return responses."""
+        return {}
 
-    def has_request_header(self, header_name):
-        raise NotImplementedError("SQS contexts don't have request headers")
+    def get_body(self) -> str:
+        """Get the SQS message body."""
+        return json.dumps(self.record)
 
-    def get_request_header(self, header_name, silent=True):
-        raise NotImplementedError("SQS contexts don't have request headers")
+    def has_body(self) -> bool:
+        """Check if SQS message has a body."""
+        return True
 
-    def get_query_parameter(self, key):
-        raise NotImplementedError("SQS contexts don't have query parameters")
+    def get_client_ip(self) -> str:
+        """SQS events don't have client IP information."""
+        return "127.0.0.1"
 
-    def get_query_parameters(self):
-        raise NotImplementedError("SQS contexts don't have query parameters")
+    def get_protocol(self) -> str:
+        """SQS events don't have a protocol."""
+        return "sqs"
+
+    def get_full_path(self) -> str:
+        """Return the configured path."""
+        return self.path
+
+    def context_specifics(self) -> dict[str, Any]:
+        """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,
+        }
+
+    @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/mocks/actions/ses.py

@@ -1,28 +1,34 @@
-from ...actions.ses import SES as BaseSES
-class SES(BaseSES):
-    calls = None
+from __future__ import annotations
+
+from typing import Any
+
+from clearskies import Model
+from types_boto3_ses import SESClient
+
+from clearskies_aws.actions.ses import SES as BaseSES
 
-    def __init__(self, environment, boto3, di):
-        super().__init__(environment, boto3, di)
+
+class SES(BaseSES):
+    calls: list[dict[str, Any]] | None = None
 
     @classmethod
     def mock(cls, di):
         cls.calls = []
         di.mock_class(BaseSES, SES)
 
-    def __call__(self, model) -> None:
+    def _execute_action(self, client: SESClient, model: Model) -> None:
         """Send a notification as configured."""
-        if SES.calls == None:
+        if SES.calls is None:
             SES.calls = []
-        utcnow = self.di.build('utcnow')
-        if self.when and not self.di.call_function(self.when, model=model):
-            return
-
-        SES.calls.append({
-            "from": self.sender,
-            "to": self._resolve_destination("to", model),
-            "cc": self._resolve_destination("cc", model),
-            "bcc": self._resolve_destination("bcc", model),
-            "subject": self._resolve_subject(model, utcnow),
-            "message": self._resolve_message_as_html(model, utcnow),
-        })
+        utcnow = self.di.build("utcnow")
+
+        SES.calls.append(
+            {
+                "from": self.sender,
+                "to": self._resolve_destination("to", model),
+                "cc": self._resolve_destination("cc", model),
+                "bcc": self._resolve_destination("bcc", model),
+                "subject": self._resolve_subject(model, utcnow),
+                "message": self._resolve_message_as_html(model, utcnow),
+            }
+        )

clearskies_aws/mocks/actions/sns.py

@@ -1,23 +1,29 @@
-from types import ModuleType
+from __future__ import annotations
+
+from typing import Any
+
 from clearskies import Model
-from ...actions.sns import SNS as BaseSNS
-class SNS(BaseSNS):
-    calls = None
+from types_boto3_sns import SNSClient
 
-    def __init__(self, environment, boto3, di):
-        super().__init__(environment, boto3, di)
+from clearskies_aws.actions.sns import SNS as BaseSNS
+
+
+class SNS(BaseSNS):
+    calls: list[dict[str, Any]] | None = None
 
     @classmethod
     def mock(cls, di):
         cls.calls = []
         di.mock_class(BaseSNS, SNS)
 
-    def _execute_action(self, client: ModuleType, model: Model) -> None:
+    def _execute_action(self, client: SNSClient, model: Model) -> None:
         """Send a notification as configured."""
-        if SNS.calls == None:
+        if SNS.calls is None:
             SNS.calls = []
 
-        SNS.calls.append({
-            "TopicArn": self.get_topic_arn(model),
-            "Message": self.get_message_body(model),
-        })
+        SNS.calls.append(
+            {
+                "TopicArn": self.get_topic_arn(model),
+                "Message": self.get_message_body(model),
+            }
+        )

clearskies_aws/mocks/actions/sqs.py

@@ -1,23 +1,29 @@
-from types import ModuleType
+from __future__ import annotations
+
+from typing import Any
+
 from clearskies import Model
-from ...actions.sqs import SQS as BaseSQS
-class SQS(BaseSQS):
-    calls = None
+from types_boto3_sqs import SQSClient
 
-    def __init__(self, environment, boto3, di):
-        super().__init__(environment, boto3, di)
+from clearskies_aws.actions.sqs import SQS as BaseSQS
+
+
+class SQS(BaseSQS):
+    calls: list[dict[str, Any]] | None = None
 
     @classmethod
     def mock(cls, di):
         cls.calls = []
         di.mock_class(BaseSQS, SQS)
 
-    def _execute_action(self, client: ModuleType, model: Model) -> None:
+    def _execute_action(self, client: SQSClient, model: Model) -> None:
         """Send a notification as configured."""
-        if SQS.calls == None:
+        if SQS.calls is None:
             SQS.calls = []
 
-        SQS.calls.append({
-            "QueueUrl": self.get_queue_url(model),
-            "MessageBody": self.get_message_body(model),
-        })
+        SQS.calls.append(
+            {
+                "QueueUrl": self.get_queue_url(model),
+                "MessageBody": self.get_message_body(model),
+            }
+        )