aws-durable-execution-sdk-python 1.1.2__tar.gz → 1.4.0__tar.gz

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/.github/workflows/ci.yml

@@ -18,7 +18,7 @@ jobs:
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6.0.2
       - name: Use Node.js
-        uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
+        uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
         with:
           node-version: 22.x
       - name: Check PR title
@@ -42,7 +42,7 @@ jobs:
         python-version: ${{ matrix.python-version }}
     - name: Install Hatch 
       run: |
-        python -m pip install hatch==1.15.0
+        python -m pip install hatch==1.16.5
     - name: static analysis
       run: hatch fmt --check
     - name: type checking

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/.github/workflows/integration-tests.yml

@@ -33,7 +33,6 @@ jobs:
       with:
         repository: aws/aws-durable-execution-sdk-python-testing
         ref: ${{ steps.parse.outputs.testing_ref }}
-        token: ${{ secrets.CROSS_REPO_PAT }}
         path: testing-sdk
 
     - name: Set up Python ${{ matrix.python-version }}
@@ -42,7 +41,7 @@ jobs:
         python-version: ${{ matrix.python-version }}
 
     - name: Install Hatch
-      run: python -m pip install hatch==1.15.0
+      run: python -m pip install hatch==1.16.5
 
     - name: Setup and run Testing SDK
       working-directory: testing-sdk
@@ -82,7 +81,6 @@ jobs:
       with:
         repository: aws/aws-durable-execution-sdk-python-testing
         ref: ${{ steps.parse.outputs.testing_ref }}
-        token: ${{ secrets.CROSS_REPO_PAT }}
         path: testing-sdk
 
     - name: Set up Python 3.13
@@ -91,7 +89,7 @@ jobs:
         python-version: '3.13'
 
     - name: Configure AWS credentials
-      uses: aws-actions/configure-aws-credentials@61815dcd50bd041e203e49132bacad1fd04d2708 # v5.1.1
+      uses: aws-actions/configure-aws-credentials@8df5847569e6427dd6c4fb1cf565c83acfa8afa7 # v6.0.0
       with:
         role-to-assume: "${{ secrets.ACTIONS_INTEGRATION_ROLE_NAME }}"
         role-session-name: languageSDKIntegrationTest
@@ -102,7 +100,7 @@ jobs:
       env:
         AWS_DURABLE_SDK_URL: file://${{ github.workspace }}/language-sdk
       run: |
-        pip install hatch==1.15.0
+        pip install hatch==1.16.5
         python -m pip install -e .
 
     - name: Get integration examples

aws_durable_execution_sdk_python-1.4.0/.github/workflows/notify_slack.yml

@@ -0,0 +1,39 @@
+name: Slack Notifications
+
+on:
+  issues:
+    types: [opened, reopened]
+  pull_request_target:
+    types: [opened, reopened]
+
+permissions: {}
+
+jobs:
+  notify:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send issue notification to Slack
+        if: github.event_name == 'issues'
+        uses: slackapi/slack-github-action@af78098f536edbc4de71162a307590698245be95 # v3.0.1
+        with:
+          webhook: ${{ secrets.SLACK_WEBHOOK_URL_ISSUE }}
+          webhook-type: incoming-webhook
+          payload: |
+            {
+              "action": "${{ github.event.action }}",
+              "issue_url": "${{ github.event.issue.html_url }}",
+              "package_name": "${{ github.repository }}"
+            }
+
+      - name: Send pull request notification to Slack
+        if: github.event_name == 'pull_request_target'
+        uses: slackapi/slack-github-action@af78098f536edbc4de71162a307590698245be95 # v3.0.1
+        with:
+          webhook: ${{ secrets.SLACK_WEBHOOK_URL_PR }}
+          webhook-type: incoming-webhook
+          payload: |
+            {
+              "action": "${{ github.event.action }}",
+              "pr_url": "${{ github.event.pull_request.html_url }}",
+              "package_name": "${{ github.repository }}"
+            }

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/.github/workflows/pypi-publish.yml

@@ -27,14 +27,14 @@ jobs:
           python-version: "3.11"
       - name: Install Hatch 
         run: |
-          python -m pip install --upgrade hatch==1.15.0
+          python -m pip install --upgrade hatch==1.16.5
       - name: Build release distributions
         run: |
           # NOTE: put your own distribution build steps here.
           hatch build
 
       - name: Upload distributions
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f  # v6.0.0
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f  # v7.0.0
         with:
           name: release-dists
           path: dist/
@@ -60,7 +60,7 @@ jobs:
 
     steps:
       - name: Retrieve release distributions
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131  # v7.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
         with:
           name: release-dists
           path: dist/

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/.github/workflows/scorecard.yml

@@ -66,7 +66,7 @@ jobs:
       # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
       # format to the repository Actions tab.
       - name: "Upload artifact"
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f  # v6.0.0
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f  # v7.0.0
         with:
           name: SARIF file
           path: results.sarif
@@ -75,6 +75,6 @@ jobs:
       # Upload the results to GitHub's code scanning dashboard (optional).
       # Commenting out will disable upload of results to your repo's Code Scanning dashboard
       - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@19b2f06db2b6f5108140aeb04014ef02b648f789 # v4.31.11
+        uses: github/codeql-action/upload-sarif@c10b8064de6f491fea524254123dbe5e09572f13 # v4.35.1
         with:
           sarif_file: results.sarif

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/.github/workflows/sync-package.yml

@@ -27,11 +27,11 @@ jobs:
           python-version: ${{ matrix.python-version }}
       - name: Install Hatch
         run: |
-          python -m pip install --upgrade hatch==1.15.0
+          python -m pip install --upgrade hatch==1.16.5
       - name: Build distribution
         run: hatch build
       - name: configure aws credentials
-        uses: aws-actions/configure-aws-credentials@61815dcd50bd041e203e49132bacad1fd04d2708 # v5.1.1
+        uses: aws-actions/configure-aws-credentials@8df5847569e6427dd6c4fb1cf565c83acfa8afa7 # v6.0.0
         with:
           role-to-assume: "${{ secrets.ACTIONS_SYNC_ROLE_NAME }}"
           role-session-name: gh-python

aws_durable_execution_sdk_python-1.1.2/docs/agents.md → aws_durable_execution_sdk_python-1.4.0/AGENTS.md

@@ -495,9 +495,10 @@ const allResults = results.getResults();
 **Python:**
 
 ```python
+from collections.abc import Sequence
 from aws_durable_execution_sdk_python.concurrency import MapConfig, CompletionConfig
 
-def process_item(ctx: DurableContext, item: dict, index: int) -> dict:
+def process_item(ctx: DurableContext, item: dict, index: int, items: Sequence[dict]) -> dict:
     return ctx.step(lambda _: process(item), name=f"process-{index}")
 
 results = context.map(
@@ -833,7 +834,7 @@ Resources:
     Type: AWS::Lambda::Function
     Properties:
       FunctionName: myDurableFunction
-      Runtime: nodejs22.x # or python3.12
+      Runtime: nodejs22.x # or python3.14
       Handler: index.handler
       Role: !GetAtt DurableFunctionRole.Arn
       Code:
@@ -894,7 +895,7 @@ Resources:
     Type: AWS::Serverless::Function
     Properties:
       FunctionName: myDurableFunction
-      Runtime: nodejs22.x # or python3.12
+      Runtime: nodejs22.x # or python3.14
       Handler: index.handler
       CodeUri: ./src
       DurableConfig:

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-durable-execution-sdk-python
-Version: 1.1.2
+Version: 1.4.0
 Summary: AWS Durable Execution SDK for Python
 Project-URL: Documentation, https://github.com/aws/aws-durable-execution-sdk-python#readme
 Project-URL: Issues, https://github.com/aws/aws-durable-execution-sdk-python/issues

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/docs/core/logger.md

@@ -14,6 +14,7 @@ The Durable Execution SDK automatically enriches your logs with execution contex
 - [Integration with Powertools for AWS Lambda (Python)](#integration-with-powertools-for-aws-lambda-python)
 - [Replay behavior and log deduplication](#replay-behavior-and-log-deduplication)
 - [Best practices](#best-practices)
+- [Enabling debug logging](#enabling-debug-logging)
 - [FAQ](#faq)
 - [Testing logger integration](#testing-logger-integration)
 - [See also](#see-also)
@@ -485,6 +486,79 @@ context.logger.info("User authenticated", extra={"password": password})
 
 [↑ Back to top](#table-of-contents)
 
+## Enabling debug logging
+
+The SDK logs internally using Python's standard `logging` module. To see these logs, set `ApplicationLogLevel: DEBUG` in [Advanced logging controls](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs-advanced.html).
+
+Advanced logging controls filters logs before they reach CloudWatch. If you set DEBUG level in code but leave Advanced logging controls at INFO, your debug logs will be dropped. You must configure the level in Advanced logging controls - it auto-patches all loggers, so you don't need to configure log levels in code.
+
+```mermaid
+flowchart LR
+    A[Logger emits DEBUG] --> B{Advanced Logging Controls}
+    B -->|ApplicationLogLevel = DEBUG| C[CloudWatch ✓]
+    B -->|ApplicationLogLevel = INFO| D[Dropped ✗]
+```
+
+**Important:** DEBUG level applies to all libraries including botocore. Since the SDK uses boto3 internally, this will flood your logs with HTTP request/response details. Silence botocore in your code:
+
+```python
+import logging
+
+# Silence botocore/urllib3 noise
+logging.getLogger("botocore").setLevel(logging.WARNING)
+logging.getLogger("urllib3").setLevel(logging.WARNING)
+```
+
+Configure ALC via SAM/CloudFormation:
+
+```yaml
+# SAM template
+Resources:
+  MyFunction:
+    Type: AWS::Serverless::Function
+    Properties:
+      LoggingConfig:
+        LogFormat: JSON
+        ApplicationLogLevel: DEBUG
+```
+
+Or in the Lambda console under Configuration → Monitoring and operations tools → Logging configuration.
+
+### Selective logging
+
+Python loggers are hierarchical. Silencing `aws_durable_execution_sdk_python` silences all SDK modules. To keep some modules at DEBUG while silencing others:
+
+```python
+import logging
+
+# Silence all SDK logs
+logging.getLogger("aws_durable_execution_sdk_python").setLevel(logging.WARNING)
+
+# Or silence specific modules only
+logging.getLogger("aws_durable_execution_sdk_python.state").setLevel(logging.WARNING)
+logging.getLogger("aws_durable_execution_sdk_python.concurrency").setLevel(logging.WARNING)
+```
+
+SDK logger namespaces:
+
+| Namespace | Description |
+|-----------|-------------|
+| `aws_durable_execution_sdk_python` | Root - silences all SDK logs |
+| `aws_durable_execution_sdk_python.state` | Checkpoint and replay state management |
+| `aws_durable_execution_sdk_python.execution` | Durable execution lifecycle |
+| `aws_durable_execution_sdk_python.context` | DurableContext operations |
+| `aws_durable_execution_sdk_python.lambda_service` | Lambda API calls |
+| `aws_durable_execution_sdk_python.serdes` | Serialization/deserialization |
+| `aws_durable_execution_sdk_python.concurrency` | Parallel and map execution |
+| `aws_durable_execution_sdk_python.operation.step` | Step operations |
+| `aws_durable_execution_sdk_python.operation.wait` | Wait operations |
+| `aws_durable_execution_sdk_python.operation.invoke` | Invoke operations |
+| `aws_durable_execution_sdk_python.operation.child` | Child context operations |
+| `aws_durable_execution_sdk_python.operation.parallel` | Parallel operations |
+| `aws_durable_execution_sdk_python.operation.map` | Map operations |
+
+[↑ Back to top](#table-of-contents)
+
 ## FAQ
 
 **Q: Does logging work during replays?**

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/docs/core/map.md

@@ -28,8 +28,6 @@
 
 **Concurrency control** - Limiting how many items process simultaneously using `max_concurrency` in `MapConfig`.
 
-**Item batching** - Grouping multiple items together for processing as a single unit to optimize efficiency.
-
 **Completion criteria** - Rules that determine when a map operation succeeds or fails based on individual item results.
 
 [↑ Back to top](#table-of-contents)
@@ -42,7 +40,7 @@ Use map operations to:
 - Transform collections with automatic checkpointing
 - Process lists of items in parallel
 - Handle large datasets with resilience
-- Control concurrency and batching behavior
+- Control concurrency behavior
 - Define custom success/failure criteria
 
 Map operations use `context.map()` to process collections efficiently. Each item becomes an independent operation that executes in parallel with other items.
@@ -55,7 +53,6 @@ Map operations use `context.map()` to process collections efficiently. Each item
 - **Independent checkpointing** - Each item's result is saved separately
 - **Partial completion** - Completed items don't reprocess on replay
 - **Concurrency control** - Limit simultaneous processing with `max_concurrency`
-- **Batching support** - Group items for efficient processing
 - **Flexible completion** - Define custom success/failure criteria
 - **Result ordering** - Results maintain the same order as inputs
 
@@ -77,19 +74,20 @@ def square(context: DurableContext, item: int, index: int, items: list[int]) ->
     return item * item
 
 @durable_execution
-def handler(event: dict, context: DurableContext) -> BatchResult[int]:
+def handler(event: dict, context: DurableContext) -> dict:
     """Process a list of items using map operations."""
     items = [1, 2, 3, 4, 5]
-    
+
     result = context.map(items, square)
-    return result
+    # Convert to dict for JSON serialization (BatchResult is not JSON serializable)
+    return result.to_dict()
 ```
 
 When this function runs:
 1. Each item is processed in parallel
 2. The `square` function is called for each item
 3. Each result is checkpointed independently
-4. The function returns a `BatchResult` with results `[1, 4, 9, 16, 25]`
+4. The function returns a dict with results `[1, 4, 9, 16, 25]`
 
 If the function is interrupted after processing items 0-2, it resumes at item 3 without reprocessing the first three items.
 
@@ -102,7 +100,7 @@ If the function is interrupted after processing items 0-2, it resumes at item 3
 ```python
 def map(
     inputs: Sequence[U],
-    func: Callable[[DurableContext, U | BatchedInput[Any, U], int, Sequence[U]], T],
+    func: Callable[[DurableContext, U, int, Sequence[U]], T],
     name: str | None = None,
     config: MapConfig | None = None,
 ) -> BatchResult[T]
@@ -113,7 +111,7 @@ def map(
 - `inputs` - A sequence of items to process (list, tuple, or any sequence type).
 - `func` - A callable that processes each item. See [Map function signature](#map-function-signature) for details.
 - `name` (optional) - A name for the map operation, useful for debugging and testing.
-- `config` (optional) - A `MapConfig` object to configure concurrency, batching, and completion criteria.
+- `config` (optional) - A `MapConfig` object to configure concurrency and completion criteria.
 
 **Returns:** A `BatchResult[T]` containing the results from processing all items.
 
@@ -128,7 +126,7 @@ The map function receives four parameters:
 ```python
 def process_item(
     context: DurableContext,
-    item: U | BatchedInput[Any, U],
+    item: U,
     index: int,
     items: Sequence[U]
 ) -> T:
@@ -140,7 +138,7 @@ def process_item(
 **Parameters:**
 
 - `context` - A `DurableContext` for the item's processing. Use this to call steps, waits, or other operations.
-- `item` - The current item being processed. Can be a `BatchedInput` if batching is configured.
+- `item` - The current item being processed.
 - `index` - The zero-based index of the item in the original collection.
 - `items` - The full collection of items being processed.
 
@@ -165,10 +163,10 @@ def validate_email(
     }
 
 @durable_execution
-def handler(event: dict, context: DurableContext) -> BatchResult[dict]:
+def handler(event: dict, context: DurableContext) -> dict:
     emails = ["jane_doe@example.com", "john_doe@example.org", "invalid"]
     result = context.map(emails, validate_email)
-    return result
+    return result.to_dict()
 ```
 
 [↑ Back to top](#table-of-contents)
@@ -186,7 +184,6 @@ from aws_durable_execution_sdk_python import (
 from aws_durable_execution_sdk_python.config import (
     MapConfig,
     CompletionConfig,
-    ItemBatcher,
 )
 
 def process_item(context: DurableContext, item: int, index: int, items: list[int]) -> dict:
@@ -194,26 +191,23 @@ def process_item(context: DurableContext, item: int, index: int, items: list[int
     return {"item": item, "squared": item * item}
 
 @durable_execution
-def handler(event: dict, context: DurableContext) -> BatchResult[dict]:
+def handler(event: dict, context: DurableContext) -> dict:
     items = list(range(100))
-    
+
     # Configure map operation
     config = MapConfig(
         max_concurrency=10,  # Process 10 items at a time
-        item_batcher=ItemBatcher(max_items_per_batch=5),  # Batch 5 items together
         completion_config=CompletionConfig.all_successful(),  # Require all to succeed
     )
-    
+
     result = context.map(items, process_item, name="process_numbers", config=config)
-    return result
+    return result.to_dict()
 ```
 
 ### MapConfig parameters
 
 **max_concurrency** - Maximum number of items to process concurrently. If `None`, all items process in parallel. Use this to control resource usage.
 
-**item_batcher** - Configuration for batching items together. Use `ItemBatcher(max_items_per_batch=N)` to group items.
-
 **completion_config** - Defines when the map operation succeeds or fails:
 - `CompletionConfig()` - Default, allows any number of failures
 - `CompletionConfig.all_successful()` - Requires all items to succeed
@@ -244,45 +238,14 @@ def fetch_data(context: DurableContext, url: str, index: int, urls: list[str]) -
     return {"url": url, "data": "..."}
 
 @durable_execution
-def handler(event: dict, context: DurableContext) -> BatchResult[dict]:
+def handler(event: dict, context: DurableContext) -> dict:
     urls = [f"https://example.com/api/{i}" for i in range(100)]
-    
+
     # Process only 5 URLs at a time
     config = MapConfig(max_concurrency=5)
-    
-    result = context.map(urls, fetch_data, config=config)
-    return result
-```
-
-### Batching items
-
-Group multiple items for efficient processing:
 
-```python
-from aws_durable_execution_sdk_python.config import MapConfig, ItemBatcher, BatchedInput
-
-def process_batch(
-    context: DurableContext,
-    batch: BatchedInput[None, int],
-    index: int,
-    items: list[int]
-) -> list[dict]:
-    """Process a batch of items together."""
-    # Process all items in the batch together
-    return [{"item": item, "squared": item * item} for item in batch.items]
-
-@durable_execution
-def handler(event: dict, context: DurableContext) -> BatchResult[list[dict]]:
-    items = list(range(100))
-    
-    # Process items in batches of 10
-    config = MapConfig(
-        item_batcher=ItemBatcher(max_items_per_batch=10)
-    )
-    
-    result = context.map(items, process_batch, config=config)
-    return result
-```
+    result = context.map(urls, fetch_data, config=config)
+    return result.to_dict()```
 
 ### Custom completion criteria
 
@@ -299,9 +262,9 @@ def process_item(context: DurableContext, item: int, index: int, items: list[int
     return {"item": item, "processed": True}
 
 @durable_execution
-def handler(event: dict, context: DurableContext) -> BatchResult[dict]:
+def handler(event: dict, context: DurableContext) -> dict:
     items = list(range(20))
-    
+
     # Succeed if at least 15 items succeed, fail after 5 failures
     config = MapConfig(
         completion_config=CompletionConfig(
@@ -309,9 +272,9 @@ def handler(event: dict, context: DurableContext) -> BatchResult[dict]:
             tolerated_failure_count=5,
         )
     )
-    
+
     result = context.map(items, process_item, config=config)
-    return result
+    return result.to_dict()
 ```
 
 ### Using context operations in map functions
@@ -344,11 +307,13 @@ def process_user(
     return {"user_id": user_id, "notification_sent": notification["sent"]}
 
 @durable_execution
-def handler(event: dict, context: DurableContext) -> BatchResult[dict]:
+def handler(event: dict, context: DurableContext) -> dict:
+    """Process multiple users using context operations within map functions."""
     user_ids = ["user_1", "user_2", "user_3"]
-    
+
     result = context.map(user_ids, process_user)
-    return result
+    # Convert to dict for JSON serialization (BatchResult is not JSON serializable)
+    return result.to_dict()
 ```
 
 ### Filtering and transforming results
@@ -391,8 +356,6 @@ def handler(event: dict, context: DurableContext) -> list[str]:
 
 **Control concurrency for external calls** - When calling external APIs, use `max_concurrency` to avoid rate limits.
 
-**Batch for efficiency** - For small, fast operations, use `item_batcher` to reduce overhead.
-
 **Define completion criteria** - Use `CompletionConfig` to specify when the operation should succeed or fail.
 
 **Keep map functions focused** - Each map function should process one item. Don't mix collection iteration with item processing.
@@ -401,7 +364,7 @@ def handler(event: dict, context: DurableContext) -> list[str]:
 
 **Handle errors gracefully** - Wrap error-prone code in try-except blocks or use completion criteria to tolerate failures.
 
-**Consider collection size** - For very large collections (10,000+ items), consider batching or processing in chunks.
+**Consider collection size** - For very large collections (10,000+ items), consider processing in chunks.
 
 **Monitor memory usage** - Large collections create many checkpoints. Monitor Lambda memory usage.
 
@@ -415,23 +378,15 @@ def handler(event: dict, context: DurableContext) -> list[str]:
 
 **Use max_concurrency wisely** - Too much concurrency can overwhelm external services or exhaust Lambda resources. Start conservative and increase as needed.
 
-**Batch small operations** - If each item processes quickly (< 100ms), batching reduces overhead:
-
-```python
-config = MapConfig(
-    item_batcher=ItemBatcher(max_items_per_batch=10)
-)
-```
-
 **Optimize map functions** - Keep map functions lightweight. Move heavy computation into steps within the map function.
 
 **Use appropriate completion criteria** - Fail fast with `tolerated_failure_count` to avoid processing remaining items when many fail.
 
 **Monitor checkpoint size** - Large result objects increase checkpoint size and Lambda memory usage. Return only necessary data.
 
-**Consider memory limits** - Processing thousands of items creates many checkpoints. Monitor Lambda memory and adjust batch size or concurrency.
+**Consider memory limits** - Processing thousands of items creates many checkpoints. Monitor Lambda memory and adjust concurrency.
 
-**Profile your workload** - Test with representative data to find optimal concurrency and batch settings.
+**Profile your workload** - Test with representative data to find optimal concurrency settings.
 
 [↑ Back to top](#table-of-contents)
 
@@ -443,7 +398,7 @@ A: Map operations process a collection of similar items using the same function.
 
 **Q: How many items can I process?**
 
-A: There's no hard limit, but consider Lambda's memory and timeout constraints. For very large collections (10,000+ items), use batching or process in chunks.
+A: There's no hard limit, but consider Lambda's memory and timeout constraints. For very large collections (10,000+ items), consider processing in chunks.
 
 **Q: Do items process in order?**
 
@@ -471,10 +426,6 @@ for item_result in batch_result.results:
 
 A: Yes, you can call `context.map()` inside a map function to process nested collections.
 
-**Q: How does batching work?**
-
-A: When you configure `item_batcher`, multiple items are grouped together and passed as a `BatchedInput` to your map function. Process all items in `batch.items`.
-
 **Q: What's the difference between serdes and item_serdes?**
 
 A: `item_serdes` serializes individual item results as they complete. `serdes` serializes the entire `BatchResult` at the end. Use both for custom serialization at different levels.

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/docs/getting-started.md

@@ -168,13 +168,14 @@ pip install aws-durable-execution-sdk-python-testing
 
 ```python
 import pytest
+from aws_durable_execution_sdk_python.execution import InvocationStatus
 from my_function import handler
 
 @pytest.mark.durable_execution(handler=handler, lambda_function_name="my_function")
 def test_my_function(durable_runner):
     with durable_runner:
         result = durable_runner.run(input={"data": "test"}, timeout=10)
-    assert result.status == "SUCCEEDED"
+    assert result.status == InvocationStatus.SUCCEEDED
 ```
 
 Run tests without AWS credentials:

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/pyproject.toml

@@ -62,9 +62,16 @@ exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
 
 [tool.ruff]
 line-length = 88
+target-version = "py311"
 
 [tool.ruff.lint]
 preview = true
+select = ["TID252"]  # Enforce absolute imports (ban relative imports)
+
+[tool.ruff.lint.isort]
+known-first-party = ["aws_durable_execution_sdk_python"]
+force-single-line = false
+lines-after-imports = 2
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = [

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/src/aws_durable_execution_sdk_python/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Amazon.com, Inc. or its affiliates.
 #
 # SPDX-License-Identifier: Apache-2.0
-__version__ = "1.1.2"
+__version__ = "1.4.0"

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/src/aws_durable_execution_sdk_python/__init__.py

@@ -1,7 +1,12 @@
 """AWS Lambda Durable Executions Python SDK."""
 
+# Package metadata
+from aws_durable_execution_sdk_python.__about__ import __version__
+
 # Main context - used in every durable function
 # Helper decorators - commonly used for step functions
+# Concurrency
+from aws_durable_execution_sdk_python.concurrency.models import BatchResult
 from aws_durable_execution_sdk_python.context import (
     DurableContext,
     durable_step,
@@ -20,7 +25,7 @@ from aws_durable_execution_sdk_python.exceptions import (
 from aws_durable_execution_sdk_python.execution import durable_execution
 
 # Essential context types - passed to user functions
-from aws_durable_execution_sdk_python.types import BatchResult, StepContext
+from aws_durable_execution_sdk_python.types import StepContext
 
 __all__ = [
     "BatchResult",
@@ -29,6 +34,7 @@ __all__ = [
     "InvocationError",
     "StepContext",
     "ValidationError",
+    "__version__",
     "durable_execution",
     "durable_step",
     "durable_wait_for_callback",

{aws_durable_execution_sdk_python-1.1.2 → aws_durable_execution_sdk_python-1.4.0}/src/aws_durable_execution_sdk_python/concurrency/executor.py

@@ -30,6 +30,7 @@ from aws_durable_execution_sdk_python.identifier import OperationIdentifier
 from aws_durable_execution_sdk_python.lambda_service import ErrorObject
 from aws_durable_execution_sdk_python.operation.child import child_handler
 
+
 if TYPE_CHECKING:
     from collections.abc import Callable
 
@@ -196,6 +197,11 @@ class ConcurrentExecutor(ABC, Generic[CallableType, ResultType]):
             "▶️ Executing concurrent operation, items: %d", len(self.executables)
         )
 
+        # Early return for empty executables
+        if not self.executables:
+            logger.debug("No items to execute, returning empty result")
+            return self._create_result()
+
         max_workers = self.max_concurrency or len(self.executables)
 
         self.executables_with_state = [