docs(batch): update single code blocks to title

Author: heitorlessa

docs/utilities/batch.md

@@ -790,51 +790,49 @@ Use the context manager to access a list of all returned values from your `recor
 * **When failed**. We will include a tuple with `fail`, exception as a string, and the batch record
 
 
-=== "app.py"
-
-    ```python hl_lines="31-38"
-    import json
+```python hl_lines="31-38" title="Accessing processed messages via context manager"
+import json
 
-    from typing import Any, List, Literal, Union
+from typing import Any, List, Literal, Union
 
-    from aws_lambda_powertools import Logger, Tracer
-    from aws_lambda_powertools.utilities.batch import (BatchProcessor,
-                                                       EventType,
-                                                       FailureResponse,
-                                                       SuccessResponse,
-                                                       batch_processor)
-    from aws_lambda_powertools.utilities.data_classes.sqs_event import SQSRecord
-    from aws_lambda_powertools.utilities.typing import LambdaContext
+from aws_lambda_powertools import Logger, Tracer
+from aws_lambda_powertools.utilities.batch import (BatchProcessor,
+												   EventType,
+												   FailureResponse,
+												   SuccessResponse,
+												   batch_processor)
+from aws_lambda_powertools.utilities.data_classes.sqs_event import SQSRecord
+from aws_lambda_powertools.utilities.typing import LambdaContext
 
 
-    processor = BatchProcessor(event_type=EventType.SQS)
-    tracer = Tracer()
-    logger = Logger()
+processor = BatchProcessor(event_type=EventType.SQS)
+tracer = Tracer()
+logger = Logger()
 
 
-    @tracer.capture_method
-    def record_handler(record: SQSRecord):
-        payload: str = record.body
-        if payload:
-            item: dict = json.loads(payload)
-        ...
+@tracer.capture_method
+def record_handler(record: SQSRecord):
+	payload: str = record.body
+	if payload:
+		item: dict = json.loads(payload)
+	...
 
-    @logger.inject_lambda_context
-    @tracer.capture_lambda_handler
-    def lambda_handler(event, context: LambdaContext):
-        batch = event["Records"]
-        with processor(records=batch, processor=processor):
-            processed_messages: List[Union[SuccessResponse, FailureResponse]] = processor.process()
+@logger.inject_lambda_context
+@tracer.capture_lambda_handler
+def lambda_handler(event, context: LambdaContext):
+	batch = event["Records"]
+	with processor(records=batch, processor=processor):
+		processed_messages: List[Union[SuccessResponse, FailureResponse]] = processor.process()
 
-        for messages in processed_messages:
-            for message in messages:
-                status: Union[Literal["success"], Literal["fail"]] = message[0]
-                result: Any = message[1]
-                record: SQSRecord = message[2]
+	for messages in processed_messages:
+		for message in messages:
+			status: Union[Literal["success"], Literal["fail"]] = message[0]
+			result: Any = message[1]
+			record: SQSRecord = message[2]
 
 
-        return processor.response()
-    ```
+	return processor.response()
+```
 
 
 ### Extending BatchProcessor
@@ -846,43 +844,40 @@ For these scenarios, you can subclass `BatchProcessor` and quickly override `suc
 * **`success_handler()`** – Keeps track of successful batch records
 * **`failure_handler()`** – Keeps track of failed batch records
 
-**Example**
+???+ example
+	Let's suppose you'd like to add a metric named `BatchRecordFailures` for each batch record that failed processing
 
-Let's suppose you'd like to add a metric named `BatchRecordFailures` for each batch record that failed processing:
+```python title="Extending failure handling mechanism in BatchProcessor"
 
-=== "app.py"
+from typing import Tuple
 
-    ```python
-
-    from typing import Tuple
-
-    from aws_lambda_powertools import Metrics
-    from aws_lambda_powertools.metrics import MetricUnit
-    from aws_lambda_powertools.utilities.batch import batch_processor, BatchProcessor, ExceptionInfo, EventType, FailureResponse
-    from aws_lambda_powertools.utilities.data_classes.sqs_event import SQSRecord
+from aws_lambda_powertools import Metrics
+from aws_lambda_powertools.metrics import MetricUnit
+from aws_lambda_powertools.utilities.batch import batch_processor, BatchProcessor, ExceptionInfo, EventType, FailureResponse
+from aws_lambda_powertools.utilities.data_classes.sqs_event import SQSRecord
 
 
-    class MyProcessor(BatchProcessor):
-        def failure_handler(self, record: SQSRecord, exception: ExceptionInfo) -> FailureResponse:
-            metrics.add_metric(name="BatchRecordFailures", unit=MetricUnit.Count, value=1)
-            return super().failure_handler(record, exception)
+class MyProcessor(BatchProcessor):
+	def failure_handler(self, record: SQSRecord, exception: ExceptionInfo) -> FailureResponse:
+		metrics.add_metric(name="BatchRecordFailures", unit=MetricUnit.Count, value=1)
+		return super().failure_handler(record, exception)
 
-    processor = MyProcessor(event_type=EventType.SQS)
-    metrics = Metrics(namespace="test")
+processor = MyProcessor(event_type=EventType.SQS)
+metrics = Metrics(namespace="test")
 
 
-    @tracer.capture_method
-    def record_handler(record: SQSRecord):
-        payload: str = record.body
-        if payload:
-            item: dict = json.loads(payload)
-        ...
+@tracer.capture_method
+def record_handler(record: SQSRecord):
+	payload: str = record.body
+	if payload:
+		item: dict = json.loads(payload)
+	...
 
-    @metrics.log_metrics(capture_cold_start_metric=True)
-    @batch_processor(record_handler=record_handler, processor=processor)
-    def lambda_handler(event, context: LambdaContext):
-        return processor.response()
-    ```
+@metrics.log_metrics(capture_cold_start_metric=True)
+@batch_processor(record_handler=record_handler, processor=processor)
+def lambda_handler(event, context: LambdaContext):
+	return processor.response()
+```
 
 ### Create your own partial processor
 
@@ -894,69 +889,67 @@ You can create your own partial batch processor from scratch by inheriting the `
 
 You can then use this class as a context manager, or pass it to `batch_processor` to use as a decorator on your Lambda handler function.
 
-=== "custom_processor.py"
-
-    ```python hl_lines="3 9 24 30 37 57"
-    from random import randint
-
-    from aws_lambda_powertools.utilities.batch import BasePartialProcessor, batch_processor
-    import boto3
-    import os
-
-    table_name = os.getenv("TABLE_NAME", "table_not_found")
-
-    class MyPartialProcessor(BasePartialProcessor):
-        """
-        Process a record and stores successful results at a Amazon DynamoDB Table
-
-        Parameters
-        ----------
-        table_name: str
-            DynamoDB table name to write results to
-        """
-
-        def __init__(self, table_name: str):
-            self.table_name = table_name
-
-            super().__init__()
-
-        def _prepare(self):
-            # It's called once, *before* processing
-            # Creates table resource and clean previous results
-            self.ddb_table = boto3.resource("dynamodb").Table(self.table_name)
-            self.success_messages.clear()
-
-        def _clean(self):
-            # It's called once, *after* closing processing all records (closing the context manager)
-            # Here we're sending, at once, all successful messages to a ddb table
-            with ddb_table.batch_writer() as batch:
-                for result in self.success_messages:
-                    batch.put_item(Item=result)
-
-        def _process_record(self, record):
-            # It handles how your record is processed
-            # Here we're keeping the status of each run
-            # where self.handler is the record_handler function passed as an argument
-            try:
-                result = self.handler(record) # record_handler passed to decorator/context manager
-                return self.success_handler(record, result)
-            except Exception as exc:
-                return self.failure_handler(record, exc)
-
-        def success_handler(self, record):
-            entry = ("success", result, record)
-            message = {"age": result}
-            self.success_messages.append(message)
-            return entry
-
-
-    def record_handler(record):
-        return randint(0, 100)
-
-    @batch_processor(record_handler=record_handler, processor=MyPartialProcessor(table_name))
-    def lambda_handler(event, context):
-        return {"statusCode": 200}
-    ```
+```python hl_lines="3 9 24 30 37 57" title="Creating a custom batch processor"
+from random import randint
+
+from aws_lambda_powertools.utilities.batch import BasePartialProcessor, batch_processor
+import boto3
+import os
+
+table_name = os.getenv("TABLE_NAME", "table_not_found")
+
+class MyPartialProcessor(BasePartialProcessor):
+	"""
+	Process a record and stores successful results at a Amazon DynamoDB Table
+
+	Parameters
+	----------
+	table_name: str
+		DynamoDB table name to write results to
+	"""
+
+	def __init__(self, table_name: str):
+		self.table_name = table_name
+
+		super().__init__()
+
+	def _prepare(self):
+		# It's called once, *before* processing
+		# Creates table resource and clean previous results
+		self.ddb_table = boto3.resource("dynamodb").Table(self.table_name)
+		self.success_messages.clear()
+
+	def _clean(self):
+		# It's called once, *after* closing processing all records (closing the context manager)
+		# Here we're sending, at once, all successful messages to a ddb table
+		with ddb_table.batch_writer() as batch:
+			for result in self.success_messages:
+				batch.put_item(Item=result)
+
+	def _process_record(self, record):
+		# It handles how your record is processed
+		# Here we're keeping the status of each run
+		# where self.handler is the record_handler function passed as an argument
+		try:
+			result = self.handler(record) # record_handler passed to decorator/context manager
+			return self.success_handler(record, result)
+		except Exception as exc:
+			return self.failure_handler(record, exc)
+
+	def success_handler(self, record):
+		entry = ("success", result, record)
+		message = {"age": result}
+		self.success_messages.append(message)
+		return entry
+
+
+def record_handler(record):
+	return randint(0, 100)
+
+@batch_processor(record_handler=record_handler, processor=MyPartialProcessor(table_name))
+def lambda_handler(event, context):
+	return {"statusCode": 200}
+```
 
 ### Caveats
 
@@ -1145,20 +1138,18 @@ When using Sentry.io for error monitoring, you can override `failure_handler` to
 
 > Credits to [Charles-Axel Dein](https://github.com/awslabs/aws-lambda-powertools-python/issues/293#issuecomment-781961732)
 
-=== "sentry_integration.py"
-
-    ```python hl_lines="4 7-8"
-    from typing import Tuple
+```python hl_lines="4 7-8" title="Integrating error tracking with Sentry.io"
+from typing import Tuple
 
-    from aws_lambda_powertools.utilities.batch import BatchProcessor, FailureResponse
-    from sentry_sdk import capture_exception
+from aws_lambda_powertools.utilities.batch import BatchProcessor, FailureResponse
+from sentry_sdk import capture_exception
 
 
-    class MyProcessor(BatchProcessor):
-        def failure_handler(self, record, exception) -> FailureResponse:
-            capture_exception()  # send exception to Sentry
-            return super().failure_handler(record, exception)
-    ```
+class MyProcessor(BatchProcessor):
+	def failure_handler(self, record, exception) -> FailureResponse:
+		capture_exception()  # send exception to Sentry
+		return super().failure_handler(record, exception)
+```
 
 
 ## Legacy