code: def _compile_inputs_for_dynamic_properties(
      context: compiler_context.PipelineContext,
      tfx_node: base_node.BaseNode,
      result: pipeline_pb2.NodeInputs,
  ) -> None:
      """Compiles additional InputSpecs used in dynamic properties.
  
      Dynamic properties are the execution properties whose value comes from the
      artifact value. Because of that, dynamic property resolution happens after
      the input resolution at orchestrator, so input resolution should include the
      resolved artifacts for the channel on which dynamic properties depend (thus
      `_compile_channel(hidden=False)`).
  
      Args:
        context: A `PipelineContext`.
        tfx_node: A `BaseNode` instance from pipeline DSL.
        result: A `NodeInputs` proto to which the compiled result would be written.
      """
      for key, exec_property in tfx_node.exec_properties.items():
          if not isinstance(exec_property, placeholder.Placeholder):
              continue
  
          # Validate all the .future().value placeholders. Note that .future().uri is
          # also allowed and doesn't need additional validation.
          for p in exec_property.traverse():
              if isinstance(
                  p, artifact_placeholder._ArtifactValueOperator
              ):  # pylint: disable=protected-access
                  for channel in channel_utils.get_dependent_channels(
                      p
                  ):
                      channel_type = (
                          channel.type
                      )  # is_compatible() needs this variable.
                      if not typing_utils.is_compatible(
                          channel_type,
                          Type[value_artifact.ValueArtifact],
                      ):
                          raise ValueError(
                              "When you pass <channel>.future().value to an execution "
                              "property, the channel must be of a value artifact type "
                              f"(String, Float, ...). Got {channel_type.TYPE_NAME} in exec "
                              f"property {key!r} of node {tfx_node.id!r}."
                          )
  
          for channel in channel_utils.get_dependent_channels(
              exec_property
          ):
              _compile_input_spec(
                  pipeline_ctx=context,
                  tfx_node=tfx_node,
                  input_key=context.get_node_context(
                      tfx_node
                  ).get_input_key(channel),
                  channel=channel,
                  hidden=False,
                  min_count=1,
                  result=result,
              )
  
imports: from typing import Type, cast
  from tfx import types
  from tfx.dsl.compiler import compiler_context
  from tfx.dsl.compiler import compiler_utils
  from tfx.dsl.compiler import constants
  from tfx.dsl.components.base import base_component
  from tfx.dsl.components.base import base_node
  from tfx.dsl.experimental.conditionals import conditional
  from tfx.dsl.input_resolution import resolver_op
  from tfx.dsl.placeholder import artifact_placeholder
  from tfx.dsl.placeholder import placeholder
  from tfx.orchestration import data_types_utils
  from tfx.proto.orchestration import metadata_pb2
  from tfx.proto.orchestration import pipeline_pb2
  from tfx.types import channel
  from tfx.types import channel_utils
  from tfx.types import resolved_channel
  from tfx.types import value_artifact
  from tfx.utils import deprecation_utils
  from tfx.utils import name_utils
  from tfx.utils import typing_utils
label_desc: Use image node_id 5 for calling a global function with example usage: _compile_inputs_for_dynamic_properties(context, tfx_node, result) without return types