code: def create_pipeline() -> pipeline_pb2.Pipeline:
      """Builds a test pipeline.
  
        ┌───────────┐
        │example_gen│
        └┬─┬─┬──────┘
         │ │┌▽──────────────┐
         │ ││stats_gen       │
         │ │└┬─────────────┬─┘
         │ │┌▽───────────┐│
         │ ││schema_gen   ││
         │ │└┬───────┬─┬──┘│
         │┌▽─▽────┐│┌▽──▽─────────────┐
         ││transform │││example_validator │
         │└┬────────┘│└───────────────────┘
        ┌▽─▽───────▽┐
        │trainer       │
        └┬─────────┬───┘
        ┌▽─────┐┌▽─────────┐
        │chore_a││evaluator  │
        └┬──────┘└───────────┘
        ┌▽──────┐
        │chore_b │
        └────────┘
  
      Returns:
        A pipeline proto for the above DAG
      """
      # pylint: disable=no-value-for-parameter
      example_gen = _example_gen().with_id("my_example_gen")
      stats_gen = _statistics_gen(
          examples=example_gen.outputs["examples"]
      ).with_id("my_statistics_gen")
      schema_gen = _schema_gen(
          statistics=stats_gen.outputs["statistics"]
      ).with_id("my_schema_gen")
      example_validator = _example_validator(
          statistics=stats_gen.outputs["statistics"],
          schema=schema_gen.outputs["schema"],
      ).with_id("my_example_validator")
      transform = _transform(
          examples=example_gen.outputs["examples"],
          schema=schema_gen.outputs["schema"],
      ).with_id("my_transform")
      trainer = _trainer(
          examples=example_gen.outputs["examples"],
          schema=schema_gen.outputs["schema"],
          transform_graph=transform.outputs["transform_graph"],
      ).with_id("my_trainer")
  
      # Nodes with no input or output specs for testing task only dependencies.
      chore_a = _chore().with_id("chore_a")
      chore_a.add_upstream_node(trainer)
      chore_b = _chore().with_id("chore_b")
      chore_b.add_upstream_node(chore_a)
  
      with conditional.Cond(
          trainer.outputs["model"]
          .future()[0]
          .custom_property("evaluate")
          == 1
      ):
          evaluator = _evaluator(
              model=trainer.outputs["model"]
          ).with_id("my_evaluator")
      # pylint: enable=no-value-for-parameter
  
      pipeline = pipeline_lib.Pipeline(
          pipeline_name="my_pipeline",
          pipeline_root="/path/to/root",
          components=[
              example_gen,
              stats_gen,
              schema_gen,
              example_validator,
              transform,
              trainer,
              evaluator,
              chore_a,
              chore_b,
          ],
          enable_cache=True,
      )
      dsl_compiler = compiler.Compiler()
      return dsl_compiler.compile(pipeline)
  
imports: from tfx.dsl.compiler import compiler
  from tfx.dsl.component.experimental.annotations import InputArtifact
  from tfx.dsl.component.experimental.annotations import OutputArtifact
  from tfx.dsl.component.experimental.decorators import component
  from tfx.dsl.control_flow.for_each import ForEach
  from tfx.dsl.experimental.conditionals import conditional
  from tfx.dsl.experimental.node_execution_options import utils
  from tfx.orchestration import pipeline
  from tfx.proto.orchestration import pipeline_pb2
  from tfx.types import standard_artifacts
label_desc: Use image node_id 9 for calling a global function with example usage: create_pipeline() and returns: dsl_compiler