code: def _resolve_command_line(
      container_spec: executor_specs.TemplatedExecutorContainerSpec,
      exec_properties: Dict[str, Any],
  ) -> List[str]:
      """Resolves placeholders in the command line of a container.
  
      Args:
        container_spec: Container structure to resolve
        exec_properties: The map of component's execution properties
  
      Returns:
        Resolved command line.
  
      Raises:
        TypeError: On unsupported type of command-line arguments, or when the
          resolved argument is not a string.
      """
  
      def expand_command_line_arg(
          cmd_arg: placeholders.CommandlineArgumentType,
      ) -> str:
          """Resolves a single argument."""
          if isinstance(cmd_arg, str):
              return cmd_arg
          elif isinstance(cmd_arg, placeholders.InputValuePlaceholder):
              if cmd_arg.input_name in exec_properties:
                  return (
                      "{{$.inputs.parameters['%s']}}"
                      % cmd_arg.input_name
                  )
              else:
                  return (
                      "{{$.inputs.artifacts['%s'].value}}"
                      % cmd_arg.input_name
                  )
          elif isinstance(cmd_arg, placeholders.InputUriPlaceholder):
              return (
                  "{{$.inputs.artifacts['%s'].uri}}"
                  % cmd_arg.input_name
              )
          elif isinstance(cmd_arg, placeholders.OutputUriPlaceholder):
              return (
                  "{{$.outputs.artifacts['%s'].uri}}"
                  % cmd_arg.output_name
              )
          elif isinstance(cmd_arg, placeholders.ConcatPlaceholder):
              resolved_items = [
                  expand_command_line_arg(item)
                  for item in cmd_arg.items
              ]
              for item in resolved_items:
                  if not isinstance(item, str):
                      raise TypeError(
                          'Expanded item "{}" has incorrect type "{}"'.format(
                              item, type(item)
                          )
                      )
              return "".join(resolved_items)
          else:
              raise TypeError(
                  'Unsupported type of command-line arguments: "{}".'
                  " Supported types are {}.".format(
                      type(cmd_arg),
                      str(executor_specs.CommandlineArgumentType),
                  )
              )
  
      resolved_command_line = []
      for cmd_arg in container_spec.command or []:
          resolved_cmd_arg = expand_command_line_arg(cmd_arg)
          if not isinstance(resolved_cmd_arg, str):
              raise TypeError(
                  'Resolved argument "{}" (type="{}") is not a string.'.format(
                      resolved_cmd_arg, type(resolved_cmd_arg)
                  )
              )
          resolved_command_line.append(resolved_cmd_arg)
  
      return resolved_command_line
  
imports: import itertools
  from typing import Any, Dict, List, Optional, Tuple, cast
  from absl import logging
  from kfp.pipeline_spec import pipeline_spec_pb2
  from tfx import components
  from tfx.components.evaluator import constants
  from tfx.dsl.compiler import compiler_utils
  from tfx.dsl.component.experimental import executor_specs
  from tfx.dsl.component.experimental import placeholders
  from tfx.dsl.components.base import base_component
  from tfx.dsl.components.base import base_node
  from tfx.dsl.components.base import executor_spec
  from tfx.dsl.components.common import importer
  from tfx.dsl.components.common import resolver
  from tfx.dsl.context_managers import dsl_context_registry
  from tfx.dsl.experimental.conditionals import conditional
  from tfx.dsl.input_resolution.strategies import latest_artifact_strategy
  from tfx.dsl.input_resolution.strategies import latest_blessed_model_strategy
  from tfx.dsl.placeholder import placeholder
  from tfx.orchestration import data_types
  from tfx.orchestration.kubeflow import decorators
  from tfx.orchestration.kubeflow import utils
  from tfx.orchestration.kubeflow.v2 import compiler_utils
  from tfx.orchestration.kubeflow.v2 import parameter_utils
  from tfx.types import channel_utils
  from tfx.types import standard_artifacts
  from tfx.types.channel import Channel
  from tfx.utils import deprecation_utils
  from tfx.utils import name_utils
  from ml_metadata.proto import metadata_store_pb2
label_desc: Use image node_id 1 for calling a global function with example usage: _resolve_command_line(container_spec, exec_properties) and returns: resolved_command_line, cmd_arg, unknown, unknown, unknown, unknown, str