feat(trigger): data class and helper functions for lambda trigger events (#159)

* feat(trigger): class wrapper for events

Put together an intial set of common lambda trigger events

* build: fix build for python 3.6

* fix(linters): make the python linters happy

* tests: add missing test cases

* docs: Include some docstrings

Tracked down some of the AWS docs to inline with the dict wrapper
classes.

* feat(trigger): initial cognito triggers

* feat(trigger): add event_bridge_event

* feat(trigger): use consistent getter name

For cases when the dict name conflicts with a python builtin we should
use a consistent method name

* refactor: less copies passed around

* feat(trigger): add UserMigrationTriggerEvent

Add support for UserMigrationTriggerEvent and include better docstrings

* feat(trigger): cognito custom message and pre-auth

Add support for CustomMessageTriggerEvent and
PreAuthenticationTriggerEvent

* feat(trigger): cognito pre token and post auth

Add support for PreTokenGenerationTriggerEvent and
PostAuthenticationTriggerEvent

* tests(trigger): some extra checks

* chore(trigger): clean up and docs

Changes:
* Add some missing docs pull for various AWS Docs
* Fix SQS mapping
* Make docs consistent

* chore: consistent naming

* feat(trigger): Add api gateway proxy events

* chore: Add more docs

* fix(trigger): better type hinting

* feat(trigger): Add conveince methods

For both SNS and S3 event notifications we actually include a single
records, so we can have conveince metods to access popular resources

* feat(trigger): Create DictWrapper

Use new DictWrapper abstract class for the data classes that wrap an
event Dict

* feat(trigger): API gateway helper methods

* feat(trigger): Kinesis stream event

Add support for Kinesis stream events with a helper method to decode
data

* feat(trigger): Application load balancer event

Create BaseProxyEvent for some reusable code for the http proxy events
Add support for ALB events

* refactor(trigger): Split decompress and parse

For handling CloudWatchLogsEvent log data split the Decode and
decompress from the parse as CloudWatchLogsDecodedData

* feat(trigger): Some attribte caching

* fix(trigger): Init with __init__

* fix(trigger): Add missing __eq__

We don't need to include `_decompressed_logs_data` and `_json_logs_data`
in equality tests

* feat(trigger): unquote_plus s3 object key

* refactor(data_classes): rename package from trigger

* refactor(data_classes): Use DictWrapper consistently

Author: michaelbrewer

aws_lambda_powertools/utilities/data_classes/__init__.py

@@ -0,0 +1,24 @@
+from .alb_event import ALBEvent
+from .api_gateway_proxy_event import APIGatewayProxyEvent, APIGatewayProxyEventV2
+from .cloud_watch_logs_event import CloudWatchLogsEvent
+from .dynamo_db_stream_event import DynamoDBStreamEvent
+from .event_bridge_event import EventBridgeEvent
+from .kinesis_stream_event import KinesisStreamEvent
+from .s3_event import S3Event
+from .ses_event import SESEvent
+from .sns_event import SNSEvent
+from .sqs_event import SQSEvent
+
+__all__ = [
+    "APIGatewayProxyEvent",
+    "APIGatewayProxyEventV2",
+    "ALBEvent",
+    "CloudWatchLogsEvent",
+    "DynamoDBStreamEvent",
+    "EventBridgeEvent",
+    "KinesisStreamEvent",
+    "S3Event",
+    "SESEvent",
+    "SNSEvent",
+    "SQSEvent",
+]

aws_lambda_powertools/utilities/data_classes/alb_event.py

@@ -0,0 +1,38 @@
+from typing import Dict, List, Optional
+
+from aws_lambda_powertools.utilities.data_classes.common import BaseProxyEvent, DictWrapper
+
+
+class ALBEventRequestContext(DictWrapper):
+    @property
+    def elb_target_group_arn(self) -> str:
+        return self["requestContext"]["elb"]["targetGroupArn"]
+
+
+class ALBEvent(BaseProxyEvent):
+    """Application load balancer event
+
+    Documentation:
+    --------------
+    - https://docs.aws.amazon.com/lambda/latest/dg/services-alb.html
+    """
+
+    @property
+    def request_context(self) -> ALBEventRequestContext:
+        return ALBEventRequestContext(self)
+
+    @property
+    def http_method(self) -> str:
+        return self["httpMethod"]
+
+    @property
+    def path(self) -> str:
+        return self["path"]
+
+    @property
+    def multi_value_query_string_parameters(self) -> Optional[Dict[str, List[str]]]:
+        return self.get("multiValueQueryStringParameters")
+
+    @property
+    def multi_value_headers(self) -> Optional[Dict[str, List[str]]]:
+        return self.get("multiValueHeaders")