localstack-core 4.10.1.dev42__py3-none-any.whl → 4.12.1.dev18__py3-none-any.whl

localstack/services/stepfunctions/asl/parse/preprocessor.py

@@ -7,13 +7,17 @@ from antlr4.tree.Tree import ParseTree, TerminalNodeImpl
 
 from localstack.services.stepfunctions.asl.antlr.runtime.ASLLexer import ASLLexer
 from localstack.services.stepfunctions.asl.antlr.runtime.ASLParser import ASLParser
-from localstack.services.stepfunctions.asl.antlr.runtime.ASLParserVisitor import ASLParserVisitor
+from localstack.services.stepfunctions.asl.antlr.runtime.ASLParserVisitor import (
+    ASLParserVisitor,
+)
 from localstack.services.stepfunctions.asl.antlt4utils.antlr4utils import (
     from_string_literal,
     is_production,
     is_terminal,
 )
-from localstack.services.stepfunctions.asl.component.common.assign.assign_decl import AssignDecl
+from localstack.services.stepfunctions.asl.component.common.assign.assign_decl import (
+    AssignDecl,
+)
 from localstack.services.stepfunctions.asl.component.common.assign.assign_decl_binding import (
     AssignDeclBinding,
 )
@@ -36,9 +40,15 @@ from localstack.services.stepfunctions.asl.component.common.assign.assign_templa
     AssignTemplateValueTerminalLit,
     AssignTemplateValueTerminalStringJSONata,
 )
-from localstack.services.stepfunctions.asl.component.common.catch.catch_decl import CatchDecl
-from localstack.services.stepfunctions.asl.component.common.catch.catcher_decl import CatcherDecl
-from localstack.services.stepfunctions.asl.component.common.catch.catcher_props import CatcherProps
+from localstack.services.stepfunctions.asl.component.common.catch.catch_decl import (
+    CatchDecl,
+)
+from localstack.services.stepfunctions.asl.component.common.catch.catcher_decl import (
+    CatcherDecl,
+)
+from localstack.services.stepfunctions.asl.component.common.catch.catcher_props import (
+    CatcherProps,
+)
 from localstack.services.stepfunctions.asl.component.common.comment import Comment
 from localstack.services.stepfunctions.asl.component.common.error_name.custom_error_name import (
     CustomErrorName,
@@ -46,7 +56,9 @@ from localstack.services.stepfunctions.asl.component.common.error_name.custom_er
 from localstack.services.stepfunctions.asl.component.common.error_name.error_equals_decl import (
     ErrorEqualsDecl,
 )
-from localstack.services.stepfunctions.asl.component.common.error_name.error_name import ErrorName
+from localstack.services.stepfunctions.asl.component.common.error_name.error_name import (
+    ErrorName,
+)
 from localstack.services.stepfunctions.asl.component.common.error_name.states_error_name import (
     StatesErrorName,
 )
@@ -79,10 +91,18 @@ from localstack.services.stepfunctions.asl.component.common.parargs import (
     Parameters,
     Parargs,
 )
-from localstack.services.stepfunctions.asl.component.common.path.input_path import InputPath
-from localstack.services.stepfunctions.asl.component.common.path.items_path import ItemsPath
-from localstack.services.stepfunctions.asl.component.common.path.output_path import OutputPath
-from localstack.services.stepfunctions.asl.component.common.path.result_path import ResultPath
+from localstack.services.stepfunctions.asl.component.common.path.input_path import (
+    InputPath,
+)
+from localstack.services.stepfunctions.asl.component.common.path.items_path import (
+    ItemsPath,
+)
+from localstack.services.stepfunctions.asl.component.common.path.output_path import (
+    OutputPath,
+)
+from localstack.services.stepfunctions.asl.component.common.path.result_path import (
+    ResultPath,
+)
 from localstack.services.stepfunctions.asl.component.common.payload.payloadvalue.payload_value import (
     PayloadValue,
 )
@@ -116,7 +136,9 @@ from localstack.services.stepfunctions.asl.component.common.query_language impor
     QueryLanguage,
     QueryLanguageMode,
 )
-from localstack.services.stepfunctions.asl.component.common.result_selector import ResultSelector
+from localstack.services.stepfunctions.asl.component.common.result_selector import (
+    ResultSelector,
+)
 from localstack.services.stepfunctions.asl.component.common.retry.backoff_rate_decl import (
     BackoffRateDecl,
 )
@@ -133,9 +155,15 @@ from localstack.services.stepfunctions.asl.component.common.retry.max_attempts_d
 from localstack.services.stepfunctions.asl.component.common.retry.max_delay_seconds_decl import (
     MaxDelaySecondsDecl,
 )
-from localstack.services.stepfunctions.asl.component.common.retry.retrier_decl import RetrierDecl
-from localstack.services.stepfunctions.asl.component.common.retry.retrier_props import RetrierProps
-from localstack.services.stepfunctions.asl.component.common.retry.retry_decl import RetryDecl
+from localstack.services.stepfunctions.asl.component.common.retry.retrier_decl import (
+    RetrierDecl,
+)
+from localstack.services.stepfunctions.asl.component.common.retry.retrier_props import (
+    RetrierProps,
+)
+from localstack.services.stepfunctions.asl.component.common.retry.retry_decl import (
+    RetryDecl,
+)
 from localstack.services.stepfunctions.asl.component.common.string.string_expression import (
     StringContextPath,
     StringExpression,
@@ -291,15 +319,23 @@ from localstack.services.stepfunctions.asl.component.state.state_fail.error_decl
     Error,
     ErrorPath,
 )
-from localstack.services.stepfunctions.asl.component.state.state_fail.state_fail import StateFail
-from localstack.services.stepfunctions.asl.component.state.state_pass.result import Result
-from localstack.services.stepfunctions.asl.component.state.state_pass.state_pass import StatePass
+from localstack.services.stepfunctions.asl.component.state.state_fail.state_fail import (
+    StateFail,
+)
+from localstack.services.stepfunctions.asl.component.state.state_pass.result import (
+    Result,
+)
+from localstack.services.stepfunctions.asl.component.state.state_pass.state_pass import (
+    StatePass,
+)
 from localstack.services.stepfunctions.asl.component.state.state_props import StateProps
 from localstack.services.stepfunctions.asl.component.state.state_succeed.state_succeed import (
     StateSucceed,
 )
 from localstack.services.stepfunctions.asl.component.state.state_type import StateType
-from localstack.services.stepfunctions.asl.component.state.state_wait.state_wait import StateWait
+from localstack.services.stepfunctions.asl.component.state.state_wait.state_wait import (
+    StateWait,
+)
 from localstack.services.stepfunctions.asl.component.state.state_wait.wait_function.seconds import (
     Seconds,
     SecondsJSONata,
@@ -311,18 +347,24 @@ from localstack.services.stepfunctions.asl.component.state.state_wait.wait_funct
     Timestamp,
     TimestampPath,
 )
-from localstack.services.stepfunctions.asl.parse.intrinsic.intrinsic_parser import IntrinsicParser
+from localstack.services.stepfunctions.asl.parse.intrinsic.intrinsic_parser import (
+    IntrinsicParser,
+)
 from localstack.services.stepfunctions.asl.parse.typed_props import TypedProps
 
 LOG = logging.getLogger(__name__)
 
 
 class Preprocessor(ASLParserVisitor):
-    _query_language_per_scope: list[QueryLanguage] = []
+    def __init__(self):
+        self._query_language_per_scope: list[QueryLanguage] = []
 
     def _get_current_query_language(self) -> QueryLanguage:
         return self._query_language_per_scope[-1]
 
+    def _get_top_level_query_language(self) -> QueryLanguage:
+        return self._query_language_per_scope[0]
+
     def _open_query_language_scope(self, parse_tree: ParseTree) -> None:
         production = is_production(parse_tree)
         if production is None:
@@ -347,11 +389,11 @@ class Preprocessor(ASLParserVisitor):
                 query_language = QueryLanguage()
         # Otherwise, check for logical conflicts and add the latest or inherited value to as the next scope.
         else:
-            current_query_language = self._get_current_query_language()
+            top_query_language = self._get_top_level_query_language()
             if query_language is None:
-                query_language = current_query_language
+                query_language = top_query_language
             if (
-                current_query_language.query_language_mode == QueryLanguageMode.JSONata
+                top_query_language.query_language_mode == QueryLanguageMode.JSONata
                 and query_language.query_language_mode == QueryLanguageMode.JSONPath
             ):
                 raise ValueError(
@@ -1507,5 +1549,6 @@ class Preprocessor(ASLParserVisitor):
         intrinsic_function_derivation = ctx.STRINGINTRINSICFUNC().getText()[1:-1]
         function, _ = IntrinsicParser.parse(intrinsic_function_derivation)
         return StringIntrinsicFunction(
-            intrinsic_function_derivation=intrinsic_function_derivation, function=function
+            intrinsic_function_derivation=intrinsic_function_derivation,
+            function=function,
         )

localstack/services/stepfunctions/asl/parse/test_state/asl_parser.py

@@ -15,7 +15,9 @@ from localstack.services.stepfunctions.asl.parse.test_state.preprocessor import
 
 class TestStateAmazonStateLanguageParser(AmazonStateLanguageParser):
     @staticmethod
-    def parse(definition: str) -> tuple[EvalComponent, ParserRuleContext]:
+    def parse(
+        definition: str, state_name: str | None = None
+    ) -> tuple[EvalComponent, ParserRuleContext]:
         # Attempt to build the AST and look out for syntax errors.
         syntax_error_listener = SyntaxErrorListener()
 
@@ -25,15 +27,14 @@ class TestStateAmazonStateLanguageParser(AmazonStateLanguageParser):
         parser = ASLParser(stream)
         parser.removeErrorListeners()
         parser.addErrorListener(syntax_error_listener)
-        # Unlike the main Program parser, TestState parsing occurs at a state declaration level.
-        tree = parser.state_decl_body()
 
+        tree = parser.state_machine() if state_name else parser.state_decl_body()
         errors = syntax_error_listener.errors
         if errors:
             raise ASLParserException(errors=errors)
 
         # Attempt to preprocess the AST into evaluation components.
         preprocessor = TestStatePreprocessor()
-        test_state_program = preprocessor.visit(tree)
+        test_state_program = preprocessor.to_test_state_program(tree, state_name)
 
         return test_state_program, tree

localstack/services/stepfunctions/asl/parse/test_state/preprocessor.py

@@ -1,9 +1,19 @@
 import enum
 from typing import Final
 
+from antlr4.tree.Tree import ParseTree
+
 from localstack.services.stepfunctions.asl.antlr.runtime.ASLParser import ASLParser
-from localstack.services.stepfunctions.asl.component.common.parargs import Parameters
+from localstack.services.stepfunctions.asl.antlt4utils.antlr4utils import (
+    is_production,
+)
+from localstack.services.stepfunctions.asl.component.common.parargs import (
+    ArgumentsJSONataTemplateValueObject,
+    ArgumentsStringJSONata,
+    Parameters,
+)
 from localstack.services.stepfunctions.asl.component.common.path.input_path import InputPath
+from localstack.services.stepfunctions.asl.component.common.path.items_path import ItemsPath
 from localstack.services.stepfunctions.asl.component.common.path.result_path import ResultPath
 from localstack.services.stepfunctions.asl.component.common.query_language import QueryLanguage
 from localstack.services.stepfunctions.asl.component.common.result_selector import ResultSelector
@@ -11,13 +21,43 @@ from localstack.services.stepfunctions.asl.component.state.state import CommonSt
 from localstack.services.stepfunctions.asl.component.state.state_choice.state_choice import (
     StateChoice,
 )
-from localstack.services.stepfunctions.asl.component.state.state_execution.execute_state import (
-    ExecutionState,
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_map.max_concurrency import (
+    MaxConcurrency,
+    MaxConcurrencyJSONata,
+    MaxConcurrencyPath,
+)
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_map.state_map import (
+    StateMap,
 )
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_map.tolerated_failure import (
+    ToleratedFailureCountInt,
+    ToleratedFailureCountPath,
+    ToleratedFailureCountStringJSONata,
+    ToleratedFailurePercentage,
+    ToleratedFailurePercentagePath,
+    ToleratedFailurePercentageStringJSONata,
+)
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.state_task import (
+    StateTask,
+)
+from localstack.services.stepfunctions.asl.component.state.state_fail.state_fail import StateFail
 from localstack.services.stepfunctions.asl.component.state.state_pass.result import Result
+from localstack.services.stepfunctions.asl.component.state.state_pass.state_pass import StatePass
+from localstack.services.stepfunctions.asl.component.state.state_succeed.state_succeed import (
+    StateSucceed,
+)
 from localstack.services.stepfunctions.asl.component.test_state.program.test_state_program import (
     TestStateProgram,
 )
+from localstack.services.stepfunctions.asl.component.test_state.state.common import (
+    MockedCommonState,
+)
+from localstack.services.stepfunctions.asl.component.test_state.state.map import (
+    MockedStateMap,
+)
+from localstack.services.stepfunctions.asl.component.test_state.state.task import (
+    MockedStateTask,
+)
 from localstack.services.stepfunctions.asl.component.test_state.state.test_state_state_props import (
     TestStateStateProps,
 )
@@ -30,63 +70,96 @@ class InspectionDataKey(enum.Enum):
     INPUT = "input"
     AFTER_INPUT_PATH = "afterInputPath"
     AFTER_PARAMETERS = "afterParameters"
+    AFTER_ARGUMENTS = "afterArguments"
     RESULT = "result"
     AFTER_RESULT_SELECTOR = "afterResultSelector"
     AFTER_RESULT_PATH = "afterResultPath"
+    AFTER_ITEMS_PATH = "afterItemsPath"
     REQUEST = "request"
     RESPONSE = "response"
 
-
-def _decorated_updated_choice_inspection_data(method):
-    def wrapper(env: TestStateEnvironment, *args, **kwargs):
-        method(env, *args, **kwargs)
-        env.set_choice_selected(env.next_state_name)
-
-    return wrapper
+    MAX_CONCURRENCY = "maxConcurrency"
+    TOLERATED_FAILURE_COUNT = "toleratedFailureCount"
+    TOLERATED_FAILURE_PERCENTAGE = "toleratedFailurePercentage"
 
 
 def _decorated_updates_inspection_data(method, inspection_data_key: InspectionDataKey):
     def wrapper(env: TestStateEnvironment, *args, **kwargs):
         method(env, *args, **kwargs)
-        result = to_json_str(env.stack[-1])
+        result = env.stack[-1]
+        if not isinstance(result, (int, float)):
+            result = to_json_str(result)
         # We know that the enum value used here corresponds to a supported inspection data field by design.
         env.inspection_data[inspection_data_key.value] = result  # noqa
 
     return wrapper
 
 
-def _decorate_state_field(state_field: CommonStateField) -> None:
-    if isinstance(state_field, ExecutionState):
-        state_field._eval_execution = _decorated_updates_inspection_data(
-            # As part of the decoration process, we intentionally access this protected member
-            # to facilitate the decorator's functionality.
-            method=state_field._eval_execution,  # noqa
-            inspection_data_key=InspectionDataKey.RESULT,
-        )
-    elif isinstance(state_field, StateChoice):
-        state_field._eval_body = _decorated_updated_choice_inspection_data(
-            # As part of the decoration process, we intentionally access this protected member
-            # to facilitate the decorator's functionality.
-            method=state_field._eval_body  # noqa
-        )
+def _decorate_state_field(state_field: CommonStateField, is_single_state: bool = False) -> None:
+    if isinstance(state_field, StateMap):
+        MockedStateMap.wrap(state_field, is_single_state)
+    elif isinstance(state_field, StateTask):
+        MockedStateTask.wrap(state_field, is_single_state)
+    elif isinstance(state_field, (StateChoice, StatePass, StateFail, StateSucceed)):
+        MockedCommonState.wrap(state_field, is_single_state)
+
+
+def find_state(state_name: str, states: dict[str, CommonStateField]) -> CommonStateField | None:
+    if state_name in states:
+        return states[state_name]
+
+    for state in states.values():
+        if isinstance(state, StateMap):
+            found_state = find_state(state_name, state.iteration_component._states.states)
+            if found_state:
+                return found_state
 
 
 class TestStatePreprocessor(Preprocessor):
-    STATE_NAME: Final[str] = "TestState"
+    STATE_NAME: Final[str] = "StateName"
+    _state_name_stack: list[str] = []
+
+    def to_test_state_program(
+        self, tree: ParseTree, state_name: str | None = None
+    ) -> TestStateProgram:
+        if is_production(tree, ASLParser.RULE_state_machine):
+            # full definition passed in
+            program = self.visitState_machine(ctx=tree)
+            state_field = find_state(state_name, program.states.states)
+            _decorate_state_field(state_field, False)
+            return TestStateProgram(state_field)
+
+        if is_production(tree, ASLParser.RULE_state_decl_body):
+            # single state case
+            state_props = self.visitState_decl_body(ctx=tree)
+            state_field = self._common_state_field_of(state_props=state_props)
+            _decorate_state_field(state_field, True)
+            return TestStateProgram(state_field)
 
-    def visitState_decl_body(self, ctx: ASLParser.State_decl_bodyContext) -> TestStateProgram:
+        return super().visit(tree)
+
+    def visitState_decl(self, ctx: ASLParser.State_declContext) -> CommonStateField:
+        # if we are parsing a full state machine, we need to record the state_name prior to stepping
+        # into the state body definition.
+        state_name = self._inner_string_of(parser_rule_context=ctx.string_literal())
+        self._state_name_stack.append(state_name)
+        state_props: TestStateStateProps = self.visit(ctx.state_decl_body())
+        state_field = self._common_state_field_of(state_props=state_props)
+        return state_field
+
+    def visitState_decl_body(self, ctx: ASLParser.State_decl_bodyContext) -> TestStateStateProps:
         self._open_query_language_scope(ctx)
         state_props = TestStateStateProps()
-        state_props.name = self.STATE_NAME
+        state_props.name = (
+            self._state_name_stack.pop(-1) if self._state_name_stack else self.STATE_NAME
+        )
         for child in ctx.children:
             cmp = self.visit(child)
             state_props.add(cmp)
-        state_field = self._common_state_field_of(state_props=state_props)
         if state_props.get(QueryLanguage) is None:
             state_props.add(self._get_current_query_language())
-        _decorate_state_field(state_field)
         self._close_query_language_scope()
-        return TestStateProgram(state_field)
+        return state_props
 
     def visitInput_path_decl(self, ctx: ASLParser.Input_path_declContext) -> InputPath:
         input_path: InputPath = super().visitInput_path_decl(ctx=ctx)
@@ -129,3 +202,121 @@ class TestStatePreprocessor(Preprocessor):
             inspection_data_key=InspectionDataKey.RESULT,  # noqa
         )
         return result
+
+    def visitMax_concurrency_int(self, ctx: ASLParser.Max_concurrency_intContext) -> MaxConcurrency:
+        max_concurrency: MaxConcurrency = super().visitMax_concurrency_int(ctx)
+        max_concurrency._eval_body = _decorated_updates_inspection_data(
+            method=max_concurrency._eval_body,
+            inspection_data_key=InspectionDataKey.MAX_CONCURRENCY,  # noqa
+        )
+        return max_concurrency
+
+    def visitMax_concurrency_jsonata(
+        self, ctx: ASLParser.Max_concurrency_jsonataContext
+    ) -> MaxConcurrencyJSONata:
+        max_concurrency_jsonata: MaxConcurrencyJSONata = super().visitMax_concurrency_jsonata(ctx)
+        max_concurrency_jsonata._eval_body = _decorated_updates_inspection_data(
+            method=max_concurrency_jsonata._eval_body,
+            inspection_data_key=InspectionDataKey.MAX_CONCURRENCY,  # noqa
+        )
+        return max_concurrency_jsonata
+
+    def visitMax_concurrency_path(
+        self, ctx: ASLParser.Max_concurrency_declContext
+    ) -> MaxConcurrencyPath:
+        max_concurrency_path: MaxConcurrencyPath = super().visitMax_concurrency_path(ctx)
+        max_concurrency_path._eval_body = _decorated_updates_inspection_data(
+            method=max_concurrency_path._eval_body,
+            inspection_data_key=InspectionDataKey.MAX_CONCURRENCY,  # noqa
+        )
+        return max_concurrency_path
+
+    def visitTolerated_failure_count_int(self, ctx) -> ToleratedFailureCountInt:
+        tolerated_failure_count: ToleratedFailureCountInt = (
+            super().visitTolerated_failure_count_int(ctx)
+        )
+        tolerated_failure_count._eval_body = _decorated_updates_inspection_data(
+            method=tolerated_failure_count._eval_body,
+            inspection_data_key=InspectionDataKey.TOLERATED_FAILURE_COUNT,
+        )
+        return tolerated_failure_count
+
+    def visitTolerated_failure_count_path(self, ctx) -> ToleratedFailureCountPath:
+        tolerated_failure_count_path: ToleratedFailureCountPath = (
+            super().visitTolerated_failure_count_path(ctx)
+        )
+        tolerated_failure_count_path._eval_body = _decorated_updates_inspection_data(
+            method=tolerated_failure_count_path._eval_body,
+            inspection_data_key=InspectionDataKey.TOLERATED_FAILURE_COUNT,
+        )
+        return tolerated_failure_count_path
+
+    def visitTolerated_failure_count_string_jsonata(
+        self, ctx
+    ) -> ToleratedFailureCountStringJSONata:
+        tolerated_failure_count_jsonata: ToleratedFailureCountStringJSONata = (
+            super().visitTolerated_failure_count_string_jsonata(ctx)
+        )
+        tolerated_failure_count_jsonata._eval_body = _decorated_updates_inspection_data(
+            method=tolerated_failure_count_jsonata._eval_body,
+            inspection_data_key=InspectionDataKey.TOLERATED_FAILURE_COUNT,
+        )
+        return tolerated_failure_count_jsonata
+
+    def visitTolerated_failure_percentage_number(self, ctx) -> ToleratedFailurePercentage:
+        tolerated_failure_percentage: ToleratedFailurePercentage = (
+            super().visitTolerated_failure_percentage_number(ctx)
+        )
+        tolerated_failure_percentage._eval_body = _decorated_updates_inspection_data(
+            method=tolerated_failure_percentage._eval_body,
+            inspection_data_key=InspectionDataKey.TOLERATED_FAILURE_PERCENTAGE,
+        )
+        return tolerated_failure_percentage
+
+    def visitTolerated_failure_percentage_path(self, ctx) -> ToleratedFailurePercentagePath:
+        tolerated_failure_percentage_path: ToleratedFailurePercentagePath = (
+            super().visitTolerated_failure_percentage_path(ctx)
+        )
+        tolerated_failure_percentage_path._eval_body = _decorated_updates_inspection_data(
+            method=tolerated_failure_percentage_path._eval_body,
+            inspection_data_key=InspectionDataKey.TOLERATED_FAILURE_PERCENTAGE,
+        )
+        return tolerated_failure_percentage_path
+
+    def visitTolerated_failure_percentage_string_jsonata(
+        self, ctx
+    ) -> ToleratedFailurePercentageStringJSONata:
+        tolerated_failure_percentage_jsonata: ToleratedFailurePercentageStringJSONata = (
+            super().visitTolerated_failure_percentage_string_jsonata(ctx)
+        )
+        tolerated_failure_percentage_jsonata._eval_body = _decorated_updates_inspection_data(
+            method=tolerated_failure_percentage_jsonata._eval_body,
+            inspection_data_key=InspectionDataKey.TOLERATED_FAILURE_PERCENTAGE,
+        )
+        return tolerated_failure_percentage_jsonata
+
+    def visitItems_path_decl(self, ctx) -> ItemsPath:
+        items_path: ItemsPath = super().visitItems_path_decl(ctx)
+        items_path._eval_body = _decorated_updates_inspection_data(
+            method=items_path._eval_body,
+            inspection_data_key=InspectionDataKey.AFTER_ITEMS_PATH,
+        )
+        return items_path
+
+    def visitArguments_string_jsonata(self, ctx):
+        arguments: ArgumentsStringJSONata = super().visitArguments_string_jsonata(ctx)
+        arguments._eval_body = _decorated_updates_inspection_data(
+            method=arguments._eval_body,
+            inspection_data_key=InspectionDataKey.AFTER_ARGUMENTS,
+        )
+        return arguments
+
+    def visitArguments_jsonata_template_value_object(self, ctx):
+        arguments: ArgumentsJSONataTemplateValueObject = (
+            super().visitArguments_jsonata_template_value_object(ctx)
+        )
+        arguments._eval_body = _decorated_updates_inspection_data(
+            method=arguments._eval_body,
+            inspection_data_key=InspectionDataKey.AFTER_ARGUMENTS,
+        )
+        return arguments