aws-cdk-lib 2.115.0__py3-none-any.whl → 2.116.1__py3-none-any.whl

aws_cdk/aws_stepfunctions/__init__.py

@@ -504,9 +504,30 @@ finish = sfn.Pass(self, "Finish")
 
 definition = choice.when(condition1, step1).otherwise(step2).afterwards().next(finish)
 
-map.iterator(definition)
+map.item_processor(definition)
 ```
 
+To define a distributed `Map` state set `itemProcessors` mode to `ProcessorMode.DISTRIBUTED`.
+An `executionType` must be specified for the distributed `Map` workflow.
+
+```python
+map = sfn.Map(self, "Map State",
+    max_concurrency=1,
+    items_path=sfn.JsonPath.string_at("$.inputForMap"),
+    parameters={
+        "item": sfn.JsonPath.string_at("$.Map.Item.Value")
+    },
+    result_path="$.mapOutput"
+)
+
+map.item_processor(sfn.Pass(self, "Pass State"),
+    mode=sfn.ProcessorMode.DISTRIBUTED,
+    execution_type=sfn.ProcessorType.STANDARD
+)
+```
+
+> Visit [Using Map state in Distributed mode to orchestrate large-scale parallel workloads](https://docs.aws.amazon.com/step-functions/latest/dg/use-dist-map-orchestrate-large-scale-parallel-workloads.html) for more details.
+
 ### Custom State
 
 It's possible that the high-level constructs for the states or `stepfunctions-tasks` do not have
@@ -564,6 +585,10 @@ custom = sfn.CustomState(self, "my custom task",
     state_json=state_json
 )
 
+# catch errors with addCatch
+error_handler = sfn.Pass(self, "handle failure")
+custom.add_catch(error_handler)
+
 chain = sfn.Chain.start(custom).next(final_status)
 
 sm = sfn.StateMachine(self, "StateMachine",
@@ -3554,7 +3579,7 @@ class Condition(
         
         definition = choice.when(condition1, step1).otherwise(step2).afterwards().next(finish)
         
-        map.iterator(definition)
+        map.item_processor(definition)
     '''
 
     def __init__(self) -> None:
@@ -4448,6 +4473,10 @@ class CustomStateProps:
                 state_json=state_json
             )
             
+            # catch errors with addCatch
+            error_handler = sfn.Pass(self, "handle failure")
+            custom.add_catch(error_handler)
+            
             chain = sfn.Chain.start(custom).next(final_status)
             
             sm = sfn.StateMachine(self, "StateMachine",
@@ -6180,18 +6209,13 @@ class JsonPath(
 
     Example::
 
-        submit_job_activity = sfn.Activity(self, "SubmitJob")
-        
-        tasks.StepFunctionsInvokeActivity(self, "Submit Job",
-            activity=submit_job_activity,
-            parameters={
-                "comment": "Selecting what I care about.",
-                "MyDetails": {
-                    "size": sfn.JsonPath.string_at("$.product.details.size"),
-                    "exists": sfn.JsonPath.string_at("$.product.availability"),
-                    "StaticValue": "foo"
-                }
-            }
+        tasks.SageMakerCreateModel(self, "Sagemaker",
+            model_name="MyModel",
+            primary_container=tasks.ContainerDefinition(
+                image=tasks.DockerImage.from_json_expression(sfn.JsonPath.string_at("$.Model.imageName")),
+                mode=tasks.Mode.SINGLE_MODEL,
+                model_s3_location=tasks.S3Location.from_json_expression("$.TrainingJob.ModelArtifacts.S3ModelArtifacts")
+            )
         )
     '''
 
@@ -6889,7 +6913,7 @@ class MapProps:
             
             definition = choice.when(condition1, step1).otherwise(step2).afterwards().next(finish)
             
-            map.iterator(definition)
+            map.item_processor(definition)
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__841961f24272e2df479ccf3f591259c5dbc7bf471c2a6e11c7c7d61bf0e153ec)
@@ -7352,6 +7376,141 @@ class PassProps:
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_stepfunctions.ProcessorConfig",
+    jsii_struct_bases=[],
+    name_mapping={"execution_type": "executionType", "mode": "mode"},
+)
+class ProcessorConfig:
+    def __init__(
+        self,
+        *,
+        execution_type: typing.Optional["ProcessorType"] = None,
+        mode: typing.Optional["ProcessorMode"] = None,
+    ) -> None:
+        '''Specifies the configuration for the processor Map state.
+
+        :param execution_type: Specifies the execution type for the Map workflow. You must provide this field if you specified ``DISTRIBUTED`` for the ``mode`` sub-field. Default: - no execution type
+        :param mode: Specifies the execution mode for the Map workflow. Default: - ProcessorMode.INLINE
+
+        :exampleMetadata: infused
+
+        Example::
+
+            map = sfn.Map(self, "Map State",
+                max_concurrency=1,
+                items_path=sfn.JsonPath.string_at("$.inputForMap"),
+                parameters={
+                    "item": sfn.JsonPath.string_at("$.Map.Item.Value")
+                },
+                result_path="$.mapOutput"
+            )
+            
+            map.item_processor(sfn.Pass(self, "Pass State"),
+                mode=sfn.ProcessorMode.DISTRIBUTED,
+                execution_type=sfn.ProcessorType.STANDARD
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__d31ff219914b0d650a3cc1eb8631c77a0fd4affa44a5d994dc200757166b4959)
+            check_type(argname="argument execution_type", value=execution_type, expected_type=type_hints["execution_type"])
+            check_type(argname="argument mode", value=mode, expected_type=type_hints["mode"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if execution_type is not None:
+            self._values["execution_type"] = execution_type
+        if mode is not None:
+            self._values["mode"] = mode
+
+    @builtins.property
+    def execution_type(self) -> typing.Optional["ProcessorType"]:
+        '''Specifies the execution type for the Map workflow.
+
+        You must provide this field if you specified ``DISTRIBUTED`` for the ``mode`` sub-field.
+
+        :default: - no execution type
+        '''
+        result = self._values.get("execution_type")
+        return typing.cast(typing.Optional["ProcessorType"], result)
+
+    @builtins.property
+    def mode(self) -> typing.Optional["ProcessorMode"]:
+        '''Specifies the execution mode for the Map workflow.
+
+        :default: - ProcessorMode.INLINE
+        '''
+        result = self._values.get("mode")
+        return typing.cast(typing.Optional["ProcessorMode"], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "ProcessorConfig(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_stepfunctions.ProcessorMode")
+class ProcessorMode(enum.Enum):
+    '''Mode of the Map workflow.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        map = sfn.Map(self, "Map State",
+            max_concurrency=1,
+            items_path=sfn.JsonPath.string_at("$.inputForMap"),
+            parameters={
+                "item": sfn.JsonPath.string_at("$.Map.Item.Value")
+            },
+            result_path="$.mapOutput"
+        )
+        
+        map.item_processor(sfn.Pass(self, "Pass State"),
+            mode=sfn.ProcessorMode.DISTRIBUTED,
+            execution_type=sfn.ProcessorType.STANDARD
+        )
+    '''
+
+    INLINE = "INLINE"
+    '''Inline Map mode.'''
+    DISTRIBUTED = "DISTRIBUTED"
+    '''Distributed Map mode.'''
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_stepfunctions.ProcessorType")
+class ProcessorType(enum.Enum):
+    '''Execution type for the Map workflow.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        map = sfn.Map(self, "Map State",
+            max_concurrency=1,
+            items_path=sfn.JsonPath.string_at("$.inputForMap"),
+            parameters={
+                "item": sfn.JsonPath.string_at("$.Map.Item.Value")
+            },
+            result_path="$.mapOutput"
+        )
+        
+        map.item_processor(sfn.Pass(self, "Pass State"),
+            mode=sfn.ProcessorMode.DISTRIBUTED,
+            execution_type=sfn.ProcessorType.STANDARD
+        )
+    '''
+
+    STANDARD = "STANDARD"
+    '''Standard execution type.'''
+    EXPRESS = "EXPRESS"
+    '''Express execution type.'''
+
+
 class Result(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.aws_stepfunctions.Result"):
     '''The result of a Pass operation.
 
@@ -7967,6 +8126,27 @@ class State(
 
         return typing.cast(None, jsii.invoke(self, "addChoice", [condition, next, options]))
 
+    @jsii.member(jsii_name="addItemProcessor")
+    def _add_item_processor(
+        self,
+        processor: "StateGraph",
+        *,
+        execution_type: typing.Optional[ProcessorType] = None,
+        mode: typing.Optional[ProcessorMode] = None,
+    ) -> None:
+        '''Add a item processor to this state.
+
+        :param processor: -
+        :param execution_type: Specifies the execution type for the Map workflow. You must provide this field if you specified ``DISTRIBUTED`` for the ``mode`` sub-field. Default: - no execution type
+        :param mode: Specifies the execution mode for the Map workflow. Default: - ProcessorMode.INLINE
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5de90784fdeaa0fa9de5d18b85a161ebed718ee0e26df2989a66073001fcb12d)
+            check_type(argname="argument processor", value=processor, expected_type=type_hints["processor"])
+        config = ProcessorConfig(execution_type=execution_type, mode=mode)
+
+        return typing.cast(None, jsii.invoke(self, "addItemProcessor", [processor, config]))
+
     @jsii.member(jsii_name="addIterator")
     def _add_iterator(self, iteration: "StateGraph") -> None:
         '''Add a map iterator to this state.
@@ -8040,6 +8220,11 @@ class State(
         '''Render InputPath/Parameters/OutputPath in ASL JSON format.'''
         return typing.cast(typing.Any, jsii.invoke(self, "renderInputOutput", []))
 
+    @jsii.member(jsii_name="renderItemProcessor")
+    def _render_item_processor(self) -> typing.Any:
+        '''Render ItemProcessor in ASL JSON format.'''
+        return typing.cast(typing.Any, jsii.invoke(self, "renderItemProcessor", []))
+
     @jsii.member(jsii_name="renderIterator")
     def _render_iterator(self) -> typing.Any:
         '''Render map iterator in ASL JSON format.'''
@@ -8175,6 +8360,30 @@ class State(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "iteration", value)
 
+    @builtins.property
+    @jsii.member(jsii_name="processor")
+    def _processor(self) -> typing.Optional["StateGraph"]:
+        return typing.cast(typing.Optional["StateGraph"], jsii.get(self, "processor"))
+
+    @_processor.setter
+    def _processor(self, value: typing.Optional["StateGraph"]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__18c6226d92e32b97a3bd2c7822b52c85358b3bd9174c0fcf373dcb3292508540)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "processor", value)
+
+    @builtins.property
+    @jsii.member(jsii_name="processorConfig")
+    def _processor_config(self) -> typing.Optional[ProcessorConfig]:
+        return typing.cast(typing.Optional[ProcessorConfig], jsii.get(self, "processorConfig"))
+
+    @_processor_config.setter
+    def _processor_config(self, value: typing.Optional[ProcessorConfig]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__2064eb72a766ce7c2f9e0be9e43dd6ea46736ba5dd83721de5468681035dcb9f)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "processorConfig", value)
+
 
 class _StateProxy(State):
     @jsii.member(jsii_name="toStateJson")
@@ -12036,7 +12245,7 @@ class Chain(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.aws_stepfunctions.Ch
         
         definition = choice.when(condition1, step1).otherwise(step2).afterwards().next(finish)
         
-        map.iterator(definition)
+        map.item_processor(definition)
     '''
 
     @jsii.member(jsii_name="custom")
@@ -12279,7 +12488,7 @@ class Choice(
         
         definition = choice.when(condition1, step1).otherwise(step2).afterwards().next(finish)
         
-        map.iterator(definition)
+        map.item_processor(definition)
     '''
 
     def __init__(
@@ -12428,6 +12637,10 @@ class CustomState(
             state_json=state_json
         )
         
+        # catch errors with addCatch
+        error_handler = sfn.Pass(self, "handle failure")
+        custom.add_catch(error_handler)
+        
         chain = sfn.Chain.start(custom).next(final_status)
         
         sm = sfn.StateMachine(self, "StateMachine",
@@ -12460,6 +12673,30 @@ class CustomState(
 
         jsii.create(self.__class__, self, [scope, id, props])
 
+    @jsii.member(jsii_name="addCatch")
+    def add_catch(
+        self,
+        handler: IChainable,
+        *,
+        errors: typing.Optional[typing.Sequence[builtins.str]] = None,
+        result_path: typing.Optional[builtins.str] = None,
+    ) -> "CustomState":
+        '''Add a recovery handler for this state.
+
+        When a particular error occurs, execution will continue at the error
+        handler instead of failing the state machine execution.
+
+        :param handler: -
+        :param errors: Errors to recover from by going to the given state. A list of error strings to retry, which can be either predefined errors (for example Errors.NoChoiceMatched) or a self-defined error. Default: All errors
+        :param result_path: JSONPath expression to indicate where to inject the error data. May also be the special value JsonPath.DISCARD, which will cause the error data to be discarded. Default: $
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__af51c0590f129eeca0846aafaf90162dc24f8f5c4a9df58d88432f4facb4ff08)
+            check_type(argname="argument handler", value=handler, expected_type=type_hints["handler"])
+        props = CatchProps(errors=errors, result_path=result_path)
+
+        return typing.cast("CustomState", jsii.invoke(self, "addCatch", [handler, props]))
+
     @jsii.member(jsii_name="next")
     def next(self, next: IChainable) -> Chain:
         '''Continue normal execution with the given state.
@@ -12589,7 +12826,7 @@ class Map(
         
         definition = choice.when(condition1, step1).otherwise(step2).afterwards().next(finish)
         
-        map.iterator(definition)
+        map.item_processor(definition)
     '''
 
     def __init__(
@@ -12696,11 +12933,40 @@ class Map(
 
         return typing.cast("Map", jsii.invoke(self, "addRetry", [props]))
 
+    @jsii.member(jsii_name="itemProcessor")
+    def item_processor(
+        self,
+        processor: IChainable,
+        *,
+        execution_type: typing.Optional[ProcessorType] = None,
+        mode: typing.Optional[ProcessorMode] = None,
+    ) -> "Map":
+        '''Define item processor in Map.
+
+        A Map must either have a non-empty iterator or a non-empty item processor, not both.
+
+        :param processor: -
+        :param execution_type: Specifies the execution type for the Map workflow. You must provide this field if you specified ``DISTRIBUTED`` for the ``mode`` sub-field. Default: - no execution type
+        :param mode: Specifies the execution mode for the Map workflow. Default: - ProcessorMode.INLINE
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__57880144217f818052832dac038a8875120f8ef30f1d286864bba6785bb1afd5)
+            check_type(argname="argument processor", value=processor, expected_type=type_hints["processor"])
+        config = ProcessorConfig(execution_type=execution_type, mode=mode)
+
+        return typing.cast("Map", jsii.invoke(self, "itemProcessor", [processor, config]))
+
     @jsii.member(jsii_name="iterator")
     def iterator(self, iterator: IChainable) -> "Map":
-        '''Define iterator state machine in Map.
+        '''(deprecated) Define iterator state machine in Map.
+
+        A Map must either have a non-empty iterator or a non-empty item processor, not both.
 
         :param iterator: -
+
+        :deprecated: - use ``itemProcessor`` instead.
+
+        :stability: deprecated
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__46bf9177a387f4dcf5be0d20783b744edaca8974e7384b16a446321cc3bc65aa)
@@ -13060,6 +13326,9 @@ __all__ = [
     "ParallelProps",
     "Pass",
     "PassProps",
+    "ProcessorConfig",
+    "ProcessorMode",
+    "ProcessorType",
     "Result",
     "RetryProps",
     "ServiceIntegrationPattern",
@@ -14170,6 +14439,14 @@ def _typecheckingstub__45d80da5dbca7702d56f2a0dd67c4a5a72e182c08bcd852d74ea0fa21
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__d31ff219914b0d650a3cc1eb8631c77a0fd4affa44a5d994dc200757166b4959(
+    *,
+    execution_type: typing.Optional[ProcessorType] = None,
+    mode: typing.Optional[ProcessorMode] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__03617b4630db9dcdb093cf33053ff1c356d21c05e74b38ea8811464bc3fd24b4(
     value: typing.Any,
 ) -> None:
@@ -14291,6 +14568,15 @@ def _typecheckingstub__df2c90f3de37dcdaf38ae6a3e70460c7cdfd78a154847df351088cd8a
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__5de90784fdeaa0fa9de5d18b85a161ebed718ee0e26df2989a66073001fcb12d(
+    processor: StateGraph,
+    *,
+    execution_type: typing.Optional[ProcessorType] = None,
+    mode: typing.Optional[ProcessorMode] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__5562e3f75801d7a93e7b5728bae35a75af70b818bb2fc8dcd8e5aa13d0766eb9(
     iteration: StateGraph,
 ) -> None:
@@ -14339,6 +14625,18 @@ def _typecheckingstub__fe26ac05d39997cba9f0b774e8732e0d7e33aa2715be53c5d2b674663
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__18c6226d92e32b97a3bd2c7822b52c85358b3bd9174c0fcf373dcb3292508540(
+    value: typing.Optional[StateGraph],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__2064eb72a766ce7c2f9e0be9e43dd6ea46736ba5dd83721de5468681035dcb9f(
+    value: typing.Optional[ProcessorConfig],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__45cc793b7e63b62353e75a13b1efe7e1c03416eb034851d41ac5b855a86cc475(
     start_state: State,
     graph_description: builtins.str,
@@ -14898,6 +15196,15 @@ def _typecheckingstub__ab8400575bd03faff673b28e1d5b185298520835ed4e6586fba73ccac
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__af51c0590f129eeca0846aafaf90162dc24f8f5c4a9df58d88432f4facb4ff08(
+    handler: IChainable,
+    *,
+    errors: typing.Optional[typing.Sequence[builtins.str]] = None,
+    result_path: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__c55cf19adb97a87b3d9f8561497d58ec4f0dc221883c0d757f4bec5f4690cadd(
     next: IChainable,
 ) -> None:
@@ -14944,6 +15251,15 @@ def _typecheckingstub__477e230f69a651e6927594095a0d2d681abd0858db9b79de5caf573bd
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__57880144217f818052832dac038a8875120f8ef30f1d286864bba6785bb1afd5(
+    processor: IChainable,
+    *,
+    execution_type: typing.Optional[ProcessorType] = None,
+    mode: typing.Optional[ProcessorMode] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__46bf9177a387f4dcf5be0d20783b744edaca8974e7384b16a446321cc3bc65aa(
     iterator: IChainable,
 ) -> None: