Merge branch 'develop' into docs/versioning

* develop:
  fix(idempotent): Correctly raise IdempotencyKeyError (#378)
  feat(event-handler): Add AppSync handler decorator (#363)
  feat(parameter): add dynamodb_endpoint_url for local_testing (#376)
  fix(parser): S3Model support empty keys (#375)
  fix(data-classes): Add missing operationName (#373)
  fix: perf tests for Logger and fail str msgs
  feat(parser): Add S3 Object Lambda Event (#362)
  build(pre-commit): Add pre-commit to make pr (#368)
  fix(tracer): Correct type hint for MyPy (#365)
  fix(metrics): AttributeError raised by MediaManager and Typing and docs (#357)

Signed-off-by: heitorlessa <lessa@amazon.co.uk>

Author: heitorlessa

Diff for: Makefile

@@ -23,7 +23,10 @@ test:
 coverage-html:
 	poetry run pytest -m "not perf" --cov=aws_lambda_powertools --cov-report=html
 
-pr: lint test security-baseline complexity-baseline
+pre-commit:
+	pre-commit run --show-diff-on-failure
+
+pr: lint pre-commit test security-baseline complexity-baseline
 
 build: pr
 	poetry build

Diff for: aws_lambda_powertools/event_handler/__init__.py

@@ -0,0 +1,7 @@
+"""
+Event handler decorators for common Lambda events
+"""
+
+from .appsync import AppSyncResolver
+
+__all__ = ["AppSyncResolver"]

Diff for: aws_lambda_powertools/event_handler/appsync.py

@@ -0,0 +1,113 @@
+import logging
+from typing import Any, Callable
+
+from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+logger = logging.getLogger(__name__)
+
+
+class AppSyncResolver:
+    """
+    AppSync resolver decorator
+
+    Example
+    -------
+
+    **Sample usage**
+
+        from aws_lambda_powertools.event_handler import AppSyncResolver
+
+        app = AppSyncResolver()
+
+        @app.resolver(type_name="Query", field_name="listLocations")
+        def list_locations(page: int = 0, size: int = 10) -> list:
+            # Your logic to fetch locations with arguments passed in
+            return [{"id": 100, "name": "Smooth Grooves"}]
+
+        @app.resolver(type_name="Merchant", field_name="extraInfo")
+        def get_extra_info() -> dict:
+            # Can use "app.current_event.source" to filter within the parent context
+            account_type = app.current_event.source["accountType"]
+            method = "BTC" if account_type == "NEW" else "USD"
+            return {"preferredPaymentMethod": method}
+
+        @app.resolver(field_name="commonField")
+        def common_field() -> str:
+            # Would match all fieldNames matching 'commonField'
+            return str(uuid.uuid4())
+    """
+
+    current_event: AppSyncResolverEvent
+    lambda_context: LambdaContext
+
+    def __init__(self):
+        self._resolvers: dict = {}
+
+    def resolver(self, type_name: str = "*", field_name: str = None):
+        """Registers the resolver for field_name
+
+        Parameters
+        ----------
+        type_name : str
+            Type name
+        field_name : str
+            Field name
+        """
+
+        def register_resolver(func):
+            logger.debug(f"Adding resolver `{func.__name__}` for field `{type_name}.{field_name}`")
+            self._resolvers[f"{type_name}.{field_name}"] = {"func": func}
+            return func
+
+        return register_resolver
+
+    def resolve(self, event: dict, context: LambdaContext) -> Any:
+        """Resolve field_name
+
+        Parameters
+        ----------
+        event : dict
+            Lambda event
+        context : LambdaContext
+            Lambda context
+
+        Returns
+        -------
+        Any
+            Returns the result of the resolver
+
+        Raises
+        -------
+        ValueError
+            If we could not find a field resolver
+        """
+        self.current_event = AppSyncResolverEvent(event)
+        self.lambda_context = context
+        resolver = self._get_resolver(self.current_event.type_name, self.current_event.field_name)
+        return resolver(**self.current_event.arguments)
+
+    def _get_resolver(self, type_name: str, field_name: str) -> Callable:
+        """Get resolver for field_name
+
+        Parameters
+        ----------
+        type_name : str
+            Type name
+        field_name : str
+            Field name
+
+        Returns
+        -------
+        Callable
+            callable function and configuration
+        """
+        full_name = f"{type_name}.{field_name}"
+        resolver = self._resolvers.get(full_name, self._resolvers.get(f"*.{field_name}"))
+        if not resolver:
+            raise ValueError(f"No resolver found for '{full_name}'")
+        return resolver["func"]
+
+    def __call__(self, event, context) -> Any:
+        """Implicit lambda handler which internally calls `resolve`"""
+        return self.resolve(event, context)

Diff for: aws_lambda_powertools/logging/lambda_context.py

@@ -1,3 +1,6 @@
+from typing import Any
+
+
 class LambdaContextModel:
     """A handful of Lambda Runtime Context fields
 
@@ -31,7 +34,7 @@ def __init__(
         self.function_request_id = function_request_id
 
 
-def build_lambda_context_model(context: object) -> LambdaContextModel:
+def build_lambda_context_model(context: Any) -> LambdaContextModel:
     """Captures Lambda function runtime info to be used across all log statements
 
     Parameters

Diff for: aws_lambda_powertools/logging/logger.py

@@ -4,7 +4,7 @@
 import os
 import random
 import sys
-from typing import Any, Callable, Dict, Union
+from typing import Any, Callable, Dict, Optional, Union
 
 import jmespath
 
@@ -318,12 +318,12 @@ def set_correlation_id(self, value: str):
         self.structure_logs(append=True, correlation_id=value)
 
     @staticmethod
-    def _get_log_level(level: Union[str, int]) -> Union[str, int]:
+    def _get_log_level(level: Union[str, int, None]) -> Union[str, int]:
         """ Returns preferred log level set by the customer in upper case """
         if isinstance(level, int):
             return level
 
-        log_level: str = level or os.getenv("LOG_LEVEL")
+        log_level: Optional[str] = level or os.getenv("LOG_LEVEL")
         if log_level is None:
             return logging.INFO
 

Diff for: aws_lambda_powertools/metrics/base.py

@@ -88,7 +88,7 @@ def __init__(
         self.service = resolve_env_var_choice(choice=service, env=os.getenv(constants.SERVICE_NAME_ENV))
         self._metric_units = [unit.value for unit in MetricUnit]
         self._metric_unit_options = list(MetricUnit.__members__)
-        self.metadata_set = self.metadata_set if metadata_set is not None else {}
+        self.metadata_set = metadata_set if metadata_set is not None else {}
 
     def add_metric(self, name: str, unit: Union[MetricUnit, str], value: float):
         """Adds given metric

Diff for: aws_lambda_powertools/metrics/metric.py

@@ -1,7 +1,7 @@
 import json
 import logging
 from contextlib import contextmanager
-from typing import Dict
+from typing import Dict, Optional, Union
 
 from .base import MetricManager, MetricUnit
 
@@ -42,7 +42,7 @@ class SingleMetric(MetricManager):
         Inherits from `aws_lambda_powertools.metrics.base.MetricManager`
     """
 
-    def add_metric(self, name: str, unit: MetricUnit, value: float):
+    def add_metric(self, name: str, unit: Union[MetricUnit, str], value: float):
         """Method to prevent more than one metric being created
 
         Parameters
@@ -109,11 +109,11 @@ def single_metric(name: str, unit: MetricUnit, value: float, namespace: str = No
     SchemaValidationError
         When metric object fails EMF schema validation
     """
-    metric_set = None
+    metric_set: Optional[Dict] = None
     try:
         metric: SingleMetric = SingleMetric(namespace=namespace)
         metric.add_metric(name=name, unit=unit, value=value)
         yield metric
-        metric_set: Dict = metric.serialize_metric_set()
+        metric_set = metric.serialize_metric_set()
     finally:
         print(json.dumps(metric_set, separators=(",", ":")))

Diff for: aws_lambda_powertools/metrics/metrics.py

@@ -2,7 +2,7 @@
 import json
 import logging
 import warnings
-from typing import Any, Callable
+from typing import Any, Callable, Dict, Optional
 
 from .base import MetricManager, MetricUnit
 from .metric import single_metric
@@ -71,15 +71,15 @@ def do_something():
         When metric object fails EMF schema validation
     """
 
-    _metrics = {}
-    _dimensions = {}
-    _metadata = {}
+    _metrics: Dict[str, Any] = {}
+    _dimensions: Dict[str, str] = {}
+    _metadata: Dict[str, Any] = {}
 
     def __init__(self, service: str = None, namespace: str = None):
         self.metric_set = self._metrics
         self.dimension_set = self._dimensions
         self.service = service
-        self.namespace = namespace
+        self.namespace: Optional[str] = namespace
         self.metadata_set = self._metadata
 
         super().__init__(

Diff for: aws_lambda_powertools/shared/functions.py

@@ -1,5 +1,5 @@
 from distutils.util import strtobool
-from typing import Any, Union
+from typing import Any, Optional, Union
 
 
 def resolve_truthy_env_var_choice(env: Any, choice: bool = None) -> bool:
@@ -22,7 +22,7 @@ def resolve_truthy_env_var_choice(env: Any, choice: bool = None) -> bool:
     return choice if choice is not None else strtobool(env)
 
 
-def resolve_env_var_choice(env: Any, choice: bool = None) -> Union[bool, Any]:
+def resolve_env_var_choice(env: Any, choice: Optional[Any] = None) -> Union[bool, Any]:
     """Pick explicit choice over env, if available, otherwise return env value received
 
     NOTE: Environment variable should be resolved by the caller.

Diff for: aws_lambda_powertools/tracing/tracer.py

@@ -244,7 +244,7 @@ def patch(self, modules: Tuple[str] = None):
 
     def capture_lambda_handler(
         self,
-        lambda_handler: Callable[[Dict, Any, Optional[Dict]], Any] = None,
+        lambda_handler: Union[Callable[[Dict, Any], Any], Callable[[Dict, Any, Optional[Dict]], Any]] = None,
         capture_response: Optional[bool] = None,
         capture_error: Optional[bool] = None,
     ):
@@ -517,7 +517,7 @@ async def async_tasks():
 
     def _decorate_async_function(
         self,
-        method: Callable = None,
+        method: Callable,
         capture_response: Optional[Union[bool, str]] = None,
         capture_error: Optional[Union[bool, str]] = None,
         method_name: str = None,
@@ -544,7 +544,7 @@ async def decorate(*args, **kwargs):
 
     def _decorate_generator_function(
         self,
-        method: Callable = None,
+        method: Callable,
         capture_response: Optional[Union[bool, str]] = None,
         capture_error: Optional[Union[bool, str]] = None,
         method_name: str = None,
@@ -571,7 +571,7 @@ def decorate(*args, **kwargs):
 
     def _decorate_generator_function_with_context_manager(
         self,
-        method: Callable = None,
+        method: Callable,
         capture_response: Optional[Union[bool, str]] = None,
         capture_error: Optional[Union[bool, str]] = None,
         method_name: str = None,
@@ -599,7 +599,7 @@ def decorate(*args, **kwargs):
 
     def _decorate_sync_function(
         self,
-        method: Callable = None,
+        method: Callable,
         capture_response: Optional[Union[bool, str]] = None,
         capture_error: Optional[Union[bool, str]] = None,
         method_name: str = None,
@@ -654,20 +654,20 @@ def _add_response_as_metadata(
 
     def _add_full_exception_as_metadata(
         self,
-        method_name: str = None,
-        error: Exception = None,
-        subsegment: BaseSegment = None,
+        method_name: str,
+        error: Exception,
+        subsegment: BaseSegment,
         capture_error: Optional[bool] = None,
     ):
         """Add full exception object as metadata for given subsegment
 
         Parameters
         ----------
-        method_name : str, optional
+        method_name : str
             method name to add as metadata key, by default None
-        error : Exception, optional
+        error : Exception
             error to add as subsegment metadata, by default None
-        subsegment : BaseSegment, optional
+        subsegment : BaseSegment
             existing subsegment to add metadata on, by default None
         capture_error : bool, optional
             Do not include error as metadata, by default True
@@ -717,7 +717,7 @@ def __build_config(
         service: str = None,
         disabled: bool = None,
         auto_patch: bool = None,
-        patch_modules: List = None,
+        patch_modules: Union[List, Tuple] = None,
         provider: BaseProvider = None,
     ):
         """ Populates Tracer config for new and existing initializations """

Diff for: aws_lambda_powertools/utilities/batch/base.py

@@ -104,7 +104,7 @@ def failure_handler(self, record: Any, exception: Tuple):
 
 @lambda_handler_decorator
 def batch_processor(
-    handler: Callable, event: Dict, context: Dict, record_handler: Callable, processor: BasePartialProcessor = None
+    handler: Callable, event: Dict, context: Dict, record_handler: Callable, processor: BasePartialProcessor
 ):
     """
     Middleware to handle batch event processing

Diff for: aws_lambda_powertools/utilities/batch/sqs.py

@@ -71,7 +71,7 @@ def _get_queue_url(self) -> Optional[str]:
         Format QueueUrl from first records entry
         """
         if not getattr(self, "records", None):
-            return
+            return None
 
         *_, account_id, queue_name = self.records[0]["eventSourceARN"].split(":")
         return f"{self.client._endpoint.host}/{account_id}/{queue_name}"

Diff for: aws_lambda_powertools/utilities/data_classes/__init__.py

@@ -1,7 +1,10 @@
-from aws_lambda_powertools.utilities.data_classes.appsync_resolver_event import AppSyncResolverEvent
+"""
+Event Source Data Classes utility provides classes self-describing Lambda event sources.
+"""
 
 from .alb_event import ALBEvent
 from .api_gateway_proxy_event import APIGatewayProxyEvent, APIGatewayProxyEventV2
+from .appsync_resolver_event import AppSyncResolverEvent
 from .cloud_watch_logs_event import CloudWatchLogsEvent
 from .connect_contact_flow_event import ConnectContactFlowEvent
 from .dynamo_db_stream_event import DynamoDBStreamEvent

Diff for: aws_lambda_powertools/utilities/data_classes/api_gateway_proxy_event.py

@@ -195,6 +195,11 @@ def route_key(self) -> Optional[str]:
         """The selected route key."""
         return self["requestContext"].get("routeKey")
 
+    @property
+    def operation_name(self) -> Optional[str]:
+        """The name of the operation being performed"""
+        return self["requestContext"].get("operationName")
+
 
 class APIGatewayProxyEvent(BaseProxyEvent):
     """AWS Lambda proxy V1