apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: calculation-pipeline-
  annotations: {pipelines.kubeflow.org/kfp_sdk_version: 1.4.0, pipelines.kubeflow.org/pipeline_compilation_time: '2021-08-03T08:02:02.376523',
    pipelines.kubeflow.org/pipeline_spec: '{"description": "A toy pipeline that performs
      arithmetic calculations.", "inputs": [{"default": "2", "name": "a", "optional":
      true, "type": "Float"}, {"default": "8", "name": "b", "optional": true, "type":
      "Float"}], "name": "Calculation pipeline"}'}
  labels: {pipelines.kubeflow.org/kfp_sdk_version: 1.4.0}
spec:
  entrypoint: calculation-pipeline
  templates:
  - name: add-op
    container:
      args: [--a, '{{inputs.parameters.a}}', --b, '4', '----output-paths', /tmp/outputs/Output/data]
      command:
      - sh
      - -ec
      - |
        program_path=$(mktemp)
        printf "%s" "$0" > "$program_path"
        python3 -u "$program_path" "$@"
      - |
        def add(a, b):
            '''Calculates sum of two arguments'''
            print(a, '+', b, '=', a + b)
            return a + b

        def _serialize_float(float_value: float) -> str:
            if isinstance(float_value, str):
                return float_value
            if not isinstance(float_value, (float, int)):
                raise TypeError('Value "{}" has type "{}" instead of float.'.format(str(float_value), str(type(float_value))))
            return str(float_value)

        import argparse
        _parser = argparse.ArgumentParser(prog='add_op', description='adds two numbers')
        _parser.add_argument("--a", dest="a", type=float, required=True, default=argparse.SUPPRESS)
        _parser.add_argument("--b", dest="b", type=float, required=True, default=argparse.SUPPRESS)
        _parser.add_argument("----output-paths", dest="_output_paths", type=str, nargs=1)
        _parsed_args = vars(_parser.parse_args())
        _output_files = _parsed_args.pop("_output_paths", [])

        _outputs = add(**_parsed_args)

        _outputs = [_outputs]

        _output_serializers = [
            _serialize_float,

        ]

        import os
        for idx, output_file in enumerate(_output_files):
            try:
                os.makedirs(os.path.dirname(output_file))
            except OSError:
                pass
            with open(output_file, 'w') as f:
                f.write(_output_serializers[idx](_outputs[idx]))
      image: python:3.8.11-slim
    inputs:
      parameters:
      - {name: a}
    outputs:
      parameters:
      - name: add-op-Output
        valueFrom: {path: /tmp/outputs/Output/data}
      artifacts:
      - {name: add-op-Output, path: /tmp/outputs/Output/data}
    metadata:
      annotations: {pipelines.kubeflow.org/component_spec: '{"description": "adds
          two numbers", "implementation": {"container": {"args": ["--a", {"inputValue":
          "a"}, "--b", {"inputValue": "b"}, "----output-paths", {"outputPath": "Output"}],
          "command": ["sh", "-ec", "program_path=$(mktemp)\nprintf \"%s\" \"$0\" >
          \"$program_path\"\npython3 -u \"$program_path\" \"$@\"\n", "def add(a, b):\n    ''''''Calculates
          sum of two arguments''''''\n    print(a, ''+'', b, ''='', a + b)\n    return
          a + b\n\ndef _serialize_float(float_value: float) -> str:\n    if isinstance(float_value,
          str):\n        return float_value\n    if not isinstance(float_value, (float,
          int)):\n        raise TypeError(''Value \"{}\" has type \"{}\" instead of
          float.''.format(str(float_value), str(type(float_value))))\n    return str(float_value)\n\nimport
          argparse\n_parser = argparse.ArgumentParser(prog=''add_op'', description=''adds
          two numbers'')\n_parser.add_argument(\"--a\", dest=\"a\", type=float, required=True,
          default=argparse.SUPPRESS)\n_parser.add_argument(\"--b\", dest=\"b\", type=float,
          required=True, default=argparse.SUPPRESS)\n_parser.add_argument(\"----output-paths\",
          dest=\"_output_paths\", type=str, nargs=1)\n_parsed_args = vars(_parser.parse_args())\n_output_files
          = _parsed_args.pop(\"_output_paths\", [])\n\n_outputs = add(**_parsed_args)\n\n_outputs
          = [_outputs]\n\n_output_serializers = [\n    _serialize_float,\n\n]\n\nimport
          os\nfor idx, output_file in enumerate(_output_files):\n    try:\n        os.makedirs(os.path.dirname(output_file))\n    except
          OSError:\n        pass\n    with open(output_file, ''w'') as f:\n        f.write(_output_serializers[idx](_outputs[idx]))\n"],
          "image": "python:3.8.11-slim"}}, "inputs": [{"name": "a", "type": "Float"},
          {"name": "b", "type": "Float"}], "name": "add_op", "outputs": [{"name":
          "Output", "type": "Float"}]}', pipelines.kubeflow.org/component_ref: '{}',
        pipelines.kubeflow.org/arguments.parameters: '{"a": "{{inputs.parameters.a}}",
          "b": "4"}'}
  - name: add-op-2
    container:
      args: [--a, '{{inputs.parameters.b}}', --b, '4', '----output-paths', /tmp/outputs/Output/data]
      command:
      - sh
      - -ec
      - |
        program_path=$(mktemp)
        printf "%s" "$0" > "$program_path"
        python3 -u "$program_path" "$@"
      - |
        def add(a, b):
            '''Calculates sum of two arguments'''
            print(a, '+', b, '=', a + b)
            return a + b

        def _serialize_float(float_value: float) -> str:
            if isinstance(float_value, str):
                return float_value
            if not isinstance(float_value, (float, int)):
                raise TypeError('Value "{}" has type "{}" instead of float.'.format(str(float_value), str(type(float_value))))
            return str(float_value)

        import argparse
        _parser = argparse.ArgumentParser(prog='add_op', description='adds two numbers')
        _parser.add_argument("--a", dest="a", type=float, required=True, default=argparse.SUPPRESS)
        _parser.add_argument("--b", dest="b", type=float, required=True, default=argparse.SUPPRESS)
        _parser.add_argument("----output-paths", dest="_output_paths", type=str, nargs=1)
        _parsed_args = vars(_parser.parse_args())
        _output_files = _parsed_args.pop("_output_paths", [])

        _outputs = add(**_parsed_args)

        _outputs = [_outputs]

        _output_serializers = [
            _serialize_float,

        ]

        import os
        for idx, output_file in enumerate(_output_files):
            try:
                os.makedirs(os.path.dirname(output_file))
            except OSError:
                pass
            with open(output_file, 'w') as f:
                f.write(_output_serializers[idx](_outputs[idx]))
      image: python:3.8.11-slim
    inputs:
      parameters:
      - {name: b}
    outputs:
      parameters:
      - name: add-op-2-Output
        valueFrom: {path: /tmp/outputs/Output/data}
      artifacts:
      - {name: add-op-2-Output, path: /tmp/outputs/Output/data}
    metadata:
      annotations: {pipelines.kubeflow.org/component_spec: '{"description": "adds
          two numbers", "implementation": {"container": {"args": ["--a", {"inputValue":
          "a"}, "--b", {"inputValue": "b"}, "----output-paths", {"outputPath": "Output"}],
          "command": ["sh", "-ec", "program_path=$(mktemp)\nprintf \"%s\" \"$0\" >
          \"$program_path\"\npython3 -u \"$program_path\" \"$@\"\n", "def add(a, b):\n    ''''''Calculates
          sum of two arguments''''''\n    print(a, ''+'', b, ''='', a + b)\n    return
          a + b\n\ndef _serialize_float(float_value: float) -> str:\n    if isinstance(float_value,
          str):\n        return float_value\n    if not isinstance(float_value, (float,
          int)):\n        raise TypeError(''Value \"{}\" has type \"{}\" instead of
          float.''.format(str(float_value), str(type(float_value))))\n    return str(float_value)\n\nimport
          argparse\n_parser = argparse.ArgumentParser(prog=''add_op'', description=''adds
          two numbers'')\n_parser.add_argument(\"--a\", dest=\"a\", type=float, required=True,
          default=argparse.SUPPRESS)\n_parser.add_argument(\"--b\", dest=\"b\", type=float,
          required=True, default=argparse.SUPPRESS)\n_parser.add_argument(\"----output-paths\",
          dest=\"_output_paths\", type=str, nargs=1)\n_parsed_args = vars(_parser.parse_args())\n_output_files
          = _parsed_args.pop(\"_output_paths\", [])\n\n_outputs = add(**_parsed_args)\n\n_outputs
          = [_outputs]\n\n_output_serializers = [\n    _serialize_float,\n\n]\n\nimport
          os\nfor idx, output_file in enumerate(_output_files):\n    try:\n        os.makedirs(os.path.dirname(output_file))\n    except
          OSError:\n        pass\n    with open(output_file, ''w'') as f:\n        f.write(_output_serializers[idx](_outputs[idx]))\n"],
          "image": "python:3.8.11-slim"}}, "inputs": [{"name": "a", "type": "Float"},
          {"name": "b", "type": "Float"}], "name": "add_op", "outputs": [{"name":
          "Output", "type": "Float"}]}', pipelines.kubeflow.org/component_ref: '{}',
        pipelines.kubeflow.org/arguments.parameters: '{"a": "{{inputs.parameters.b}}",
          "b": "4"}'}
  - name: add-op-3
    container:
      args: [--a, '{{inputs.parameters.add-op-Output}}', --b, '{{inputs.parameters.add-op-2-Output}}',
        '----output-paths', /tmp/outputs/Output/data]
      command:
      - sh
      - -ec
      - |
        program_path=$(mktemp)
        printf "%s" "$0" > "$program_path"
        python3 -u "$program_path" "$@"
      - |
        def add(a, b):
            '''Calculates sum of two arguments'''
            print(a, '+', b, '=', a + b)
            return a + b

        def _serialize_float(float_value: float) -> str:
            if isinstance(float_value, str):
                return float_value
            if not isinstance(float_value, (float, int)):
                raise TypeError('Value "{}" has type "{}" instead of float.'.format(str(float_value), str(type(float_value))))
            return str(float_value)

        import argparse
        _parser = argparse.ArgumentParser(prog='add_op', description='adds two numbers')
        _parser.add_argument("--a", dest="a", type=float, required=True, default=argparse.SUPPRESS)
        _parser.add_argument("--b", dest="b", type=float, required=True, default=argparse.SUPPRESS)
        _parser.add_argument("----output-paths", dest="_output_paths", type=str, nargs=1)
        _parsed_args = vars(_parser.parse_args())
        _output_files = _parsed_args.pop("_output_paths", [])

        _outputs = add(**_parsed_args)

        _outputs = [_outputs]

        _output_serializers = [
            _serialize_float,

        ]

        import os
        for idx, output_file in enumerate(_output_files):
            try:
                os.makedirs(os.path.dirname(output_file))
            except OSError:
                pass
            with open(output_file, 'w') as f:
                f.write(_output_serializers[idx](_outputs[idx]))
      image: python:3.8.11-slim
    inputs:
      parameters:
      - {name: add-op-2-Output}
      - {name: add-op-Output}
    outputs:
      parameters:
      - name: add-op-3-Output
        valueFrom: {path: /tmp/outputs/Output/data}
      artifacts:
      - {name: add-op-3-Output, path: /tmp/outputs/Output/data}
    metadata:
      annotations: {pipelines.kubeflow.org/component_spec: '{"description": "adds
          two numbers", "implementation": {"container": {"args": ["--a", {"inputValue":
          "a"}, "--b", {"inputValue": "b"}, "----output-paths", {"outputPath": "Output"}],
          "command": ["sh", "-ec", "program_path=$(mktemp)\nprintf \"%s\" \"$0\" >
          \"$program_path\"\npython3 -u \"$program_path\" \"$@\"\n", "def add(a, b):\n    ''''''Calculates
          sum of two arguments''''''\n    print(a, ''+'', b, ''='', a + b)\n    return
          a + b\n\ndef _serialize_float(float_value: float) -> str:\n    if isinstance(float_value,
          str):\n        return float_value\n    if not isinstance(float_value, (float,
          int)):\n        raise TypeError(''Value \"{}\" has type \"{}\" instead of
          float.''.format(str(float_value), str(type(float_value))))\n    return str(float_value)\n\nimport
          argparse\n_parser = argparse.ArgumentParser(prog=''add_op'', description=''adds
          two numbers'')\n_parser.add_argument(\"--a\", dest=\"a\", type=float, required=True,
          default=argparse.SUPPRESS)\n_parser.add_argument(\"--b\", dest=\"b\", type=float,
          required=True, default=argparse.SUPPRESS)\n_parser.add_argument(\"----output-paths\",
          dest=\"_output_paths\", type=str, nargs=1)\n_parsed_args = vars(_parser.parse_args())\n_output_files
          = _parsed_args.pop(\"_output_paths\", [])\n\n_outputs = add(**_parsed_args)\n\n_outputs
          = [_outputs]\n\n_output_serializers = [\n    _serialize_float,\n\n]\n\nimport
          os\nfor idx, output_file in enumerate(_output_files):\n    try:\n        os.makedirs(os.path.dirname(output_file))\n    except
          OSError:\n        pass\n    with open(output_file, ''w'') as f:\n        f.write(_output_serializers[idx](_outputs[idx]))\n"],
          "image": "python:3.8.11-slim"}}, "inputs": [{"name": "a", "type": "Float"},
          {"name": "b", "type": "Float"}], "name": "add_op", "outputs": [{"name":
          "Output", "type": "Float"}]}', pipelines.kubeflow.org/component_ref: '{}',
        pipelines.kubeflow.org/arguments.parameters: '{"a": "{{inputs.parameters.add-op-Output}}",
          "b": "{{inputs.parameters.add-op-2-Output}}"}'}
  - name: add-op-4
    container:
      args: [--a, '{{inputs.parameters.a}}', --b, '{{inputs.parameters.add-op-3-Output}}',
        '----output-paths', /tmp/outputs/Output/data]
      command:
      - sh
      - -ec
      - |
        program_path=$(mktemp)
        printf "%s" "$0" > "$program_path"
        python3 -u "$program_path" "$@"
      - |
        def add(a, b):
            '''Calculates sum of two arguments'''
            print(a, '+', b, '=', a + b)
            return a + b

        def _serialize_float(float_value: float) -> str:
            if isinstance(float_value, str):
                return float_value
            if not isinstance(float_value, (float, int)):
                raise TypeError('Value "{}" has type "{}" instead of float.'.format(str(float_value), str(type(float_value))))
            return str(float_value)

        import argparse
        _parser = argparse.ArgumentParser(prog='add_op', description='adds two numbers')
        _parser.add_argument("--a", dest="a", type=float, required=True, default=argparse.SUPPRESS)
        _parser.add_argument("--b", dest="b", type=float, required=True, default=argparse.SUPPRESS)
        _parser.add_argument("----output-paths", dest="_output_paths", type=str, nargs=1)
        _parsed_args = vars(_parser.parse_args())
        _output_files = _parsed_args.pop("_output_paths", [])

        _outputs = add(**_parsed_args)

        _outputs = [_outputs]

        _output_serializers = [
            _serialize_float,

        ]

        import os
        for idx, output_file in enumerate(_output_files):
            try:
                os.makedirs(os.path.dirname(output_file))
            except OSError:
                pass
            with open(output_file, 'w') as f:
                f.write(_output_serializers[idx](_outputs[idx]))
      image: python:3.8.11-slim
    inputs:
      parameters:
      - {name: a}
      - {name: add-op-3-Output}
    outputs:
      parameters:
      - name: add-op-4-Output
        valueFrom: {path: /tmp/outputs/Output/data}
      artifacts:
      - {name: add-op-4-Output, path: /tmp/outputs/Output/data}
    metadata:
      annotations: {pipelines.kubeflow.org/component_spec: '{"description": "adds
          two numbers", "implementation": {"container": {"args": ["--a", {"inputValue":
          "a"}, "--b", {"inputValue": "b"}, "----output-paths", {"outputPath": "Output"}],
          "command": ["sh", "-ec", "program_path=$(mktemp)\nprintf \"%s\" \"$0\" >
          \"$program_path\"\npython3 -u \"$program_path\" \"$@\"\n", "def add(a, b):\n    ''''''Calculates
          sum of two arguments''''''\n    print(a, ''+'', b, ''='', a + b)\n    return
          a + b\n\ndef _serialize_float(float_value: float) -> str:\n    if isinstance(float_value,
          str):\n        return float_value\n    if not isinstance(float_value, (float,
          int)):\n        raise TypeError(''Value \"{}\" has type \"{}\" instead of
          float.''.format(str(float_value), str(type(float_value))))\n    return str(float_value)\n\nimport
          argparse\n_parser = argparse.ArgumentParser(prog=''add_op'', description=''adds
          two numbers'')\n_parser.add_argument(\"--a\", dest=\"a\", type=float, required=True,
          default=argparse.SUPPRESS)\n_parser.add_argument(\"--b\", dest=\"b\", type=float,
          required=True, default=argparse.SUPPRESS)\n_parser.add_argument(\"----output-paths\",
          dest=\"_output_paths\", type=str, nargs=1)\n_parsed_args = vars(_parser.parse_args())\n_output_files
          = _parsed_args.pop(\"_output_paths\", [])\n\n_outputs = add(**_parsed_args)\n\n_outputs
          = [_outputs]\n\n_output_serializers = [\n    _serialize_float,\n\n]\n\nimport
          os\nfor idx, output_file in enumerate(_output_files):\n    try:\n        os.makedirs(os.path.dirname(output_file))\n    except
          OSError:\n        pass\n    with open(output_file, ''w'') as f:\n        f.write(_output_serializers[idx](_outputs[idx]))\n"],
          "image": "python:3.8.11-slim"}}, "inputs": [{"name": "a", "type": "Float"},
          {"name": "b", "type": "Float"}], "name": "add_op", "outputs": [{"name":
          "Output", "type": "Float"}]}', pipelines.kubeflow.org/component_ref: '{}',
        pipelines.kubeflow.org/arguments.parameters: '{"a": "{{inputs.parameters.a}}",
          "b": "{{inputs.parameters.add-op-3-Output}}"}'}
  - name: add-op-5
    container:
      args: [--a, '{{inputs.parameters.b}}', --b, '{{inputs.parameters.add-op-3-Output}}',
        '----output-paths', /tmp/outputs/Output/data]
      command:
      - sh
      - -ec
      - |
        program_path=$(mktemp)
        printf "%s" "$0" > "$program_path"
        python3 -u "$program_path" "$@"
      - |
        def add(a, b):
            '''Calculates sum of two arguments'''
            print(a, '+', b, '=', a + b)
            return a + b

        def _serialize_float(float_value: float) -> str:
            if isinstance(float_value, str):
                return float_value
            if not isinstance(float_value, (float, int)):
                raise TypeError('Value "{}" has type "{}" instead of float.'.format(str(float_value), str(type(float_value))))
            return str(float_value)

        import argparse
        _parser = argparse.ArgumentParser(prog='add_op', description='adds two numbers')
        _parser.add_argument("--a", dest="a", type=float, required=True, default=argparse.SUPPRESS)
        _parser.add_argument("--b", dest="b", type=float, required=True, default=argparse.SUPPRESS)
        _parser.add_argument("----output-paths", dest="_output_paths", type=str, nargs=1)
        _parsed_args = vars(_parser.parse_args())
        _output_files = _parsed_args.pop("_output_paths", [])

        _outputs = add(**_parsed_args)

        _outputs = [_outputs]

        _output_serializers = [
            _serialize_float,

        ]

        import os
        for idx, output_file in enumerate(_output_files):
            try:
                os.makedirs(os.path.dirname(output_file))
            except OSError:
                pass
            with open(output_file, 'w') as f:
                f.write(_output_serializers[idx](_outputs[idx]))
      image: python:3.8.11-slim
    inputs:
      parameters:
      - {name: add-op-3-Output}
      - {name: b}
    outputs:
      parameters:
      - name: add-op-5-Output
        valueFrom: {path: /tmp/outputs/Output/data}
      artifacts:
      - {name: add-op-5-Output, path: /tmp/outputs/Output/data}
    metadata:
      annotations: {pipelines.kubeflow.org/component_spec: '{"description": "adds
          two numbers", "implementation": {"container": {"args": ["--a", {"inputValue":
          "a"}, "--b", {"inputValue": "b"}, "----output-paths", {"outputPath": "Output"}],
          "command": ["sh", "-ec", "program_path=$(mktemp)\nprintf \"%s\" \"$0\" >
          \"$program_path\"\npython3 -u \"$program_path\" \"$@\"\n", "def add(a, b):\n    ''''''Calculates
          sum of two arguments''''''\n    print(a, ''+'', b, ''='', a + b)\n    return
          a + b\n\ndef _serialize_float(float_value: float) -> str:\n    if isinstance(float_value,
          str):\n        return float_value\n    if not isinstance(float_value, (float,
          int)):\n        raise TypeError(''Value \"{}\" has type \"{}\" instead of
          float.''.format(str(float_value), str(type(float_value))))\n    return str(float_value)\n\nimport
          argparse\n_parser = argparse.ArgumentParser(prog=''add_op'', description=''adds
          two numbers'')\n_parser.add_argument(\"--a\", dest=\"a\", type=float, required=True,
          default=argparse.SUPPRESS)\n_parser.add_argument(\"--b\", dest=\"b\", type=float,
          required=True, default=argparse.SUPPRESS)\n_parser.add_argument(\"----output-paths\",
          dest=\"_output_paths\", type=str, nargs=1)\n_parsed_args = vars(_parser.parse_args())\n_output_files
          = _parsed_args.pop(\"_output_paths\", [])\n\n_outputs = add(**_parsed_args)\n\n_outputs
          = [_outputs]\n\n_output_serializers = [\n    _serialize_float,\n\n]\n\nimport
          os\nfor idx, output_file in enumerate(_output_files):\n    try:\n        os.makedirs(os.path.dirname(output_file))\n    except
          OSError:\n        pass\n    with open(output_file, ''w'') as f:\n        f.write(_output_serializers[idx](_outputs[idx]))\n"],
          "image": "python:3.8.11-slim"}}, "inputs": [{"name": "a", "type": "Float"},
          {"name": "b", "type": "Float"}], "name": "add_op", "outputs": [{"name":
          "Output", "type": "Float"}]}', pipelines.kubeflow.org/component_ref: '{}',
        pipelines.kubeflow.org/arguments.parameters: '{"a": "{{inputs.parameters.b}}",
          "b": "{{inputs.parameters.add-op-3-Output}}"}'}
  - name: add-op-6
    container:
      args: [--a, '{{inputs.parameters.add-op-4-Output}}', --b, '{{inputs.parameters.add-op-5-Output}}',
        '----output-paths', /tmp/outputs/Output/data]
      command:
      - sh
      - -ec
      - |
        program_path=$(mktemp)
        printf "%s" "$0" > "$program_path"
        python3 -u "$program_path" "$@"
      - |
        def add(a, b):
            '''Calculates sum of two arguments'''
            print(a, '+', b, '=', a + b)
            return a + b

        def _serialize_float(float_value: float) -> str:
            if isinstance(float_value, str):
                return float_value
            if not isinstance(float_value, (float, int)):
                raise TypeError('Value "{}" has type "{}" instead of float.'.format(str(float_value), str(type(float_value))))
            return str(float_value)

        import argparse
        _parser = argparse.ArgumentParser(prog='add_op', description='adds two numbers')
        _parser.add_argument("--a", dest="a", type=float, required=True, default=argparse.SUPPRESS)
        _parser.add_argument("--b", dest="b", type=float, required=True, default=argparse.SUPPRESS)
        _parser.add_argument("----output-paths", dest="_output_paths", type=str, nargs=1)
        _parsed_args = vars(_parser.parse_args())
        _output_files = _parsed_args.pop("_output_paths", [])

        _outputs = add(**_parsed_args)

        _outputs = [_outputs]

        _output_serializers = [
            _serialize_float,

        ]

        import os
        for idx, output_file in enumerate(_output_files):
            try:
                os.makedirs(os.path.dirname(output_file))
            except OSError:
                pass
            with open(output_file, 'w') as f:
                f.write(_output_serializers[idx](_outputs[idx]))
      image: python:3.8.11-slim
    inputs:
      parameters:
      - {name: add-op-4-Output}
      - {name: add-op-5-Output}
    outputs:
      artifacts:
      - {name: add-op-6-Output, path: /tmp/outputs/Output/data}
    metadata:
      annotations: {pipelines.kubeflow.org/component_spec: '{"description": "adds
          two numbers", "implementation": {"container": {"args": ["--a", {"inputValue":
          "a"}, "--b", {"inputValue": "b"}, "----output-paths", {"outputPath": "Output"}],
          "command": ["sh", "-ec", "program_path=$(mktemp)\nprintf \"%s\" \"$0\" >
          \"$program_path\"\npython3 -u \"$program_path\" \"$@\"\n", "def add(a, b):\n    ''''''Calculates
          sum of two arguments''''''\n    print(a, ''+'', b, ''='', a + b)\n    return
          a + b\n\ndef _serialize_float(float_value: float) -> str:\n    if isinstance(float_value,
          str):\n        return float_value\n    if not isinstance(float_value, (float,
          int)):\n        raise TypeError(''Value \"{}\" has type \"{}\" instead of
          float.''.format(str(float_value), str(type(float_value))))\n    return str(float_value)\n\nimport
          argparse\n_parser = argparse.ArgumentParser(prog=''add_op'', description=''adds
          two numbers'')\n_parser.add_argument(\"--a\", dest=\"a\", type=float, required=True,
          default=argparse.SUPPRESS)\n_parser.add_argument(\"--b\", dest=\"b\", type=float,
          required=True, default=argparse.SUPPRESS)\n_parser.add_argument(\"----output-paths\",
          dest=\"_output_paths\", type=str, nargs=1)\n_parsed_args = vars(_parser.parse_args())\n_output_files
          = _parsed_args.pop(\"_output_paths\", [])\n\n_outputs = add(**_parsed_args)\n\n_outputs
          = [_outputs]\n\n_output_serializers = [\n    _serialize_float,\n\n]\n\nimport
          os\nfor idx, output_file in enumerate(_output_files):\n    try:\n        os.makedirs(os.path.dirname(output_file))\n    except
          OSError:\n        pass\n    with open(output_file, ''w'') as f:\n        f.write(_output_serializers[idx](_outputs[idx]))\n"],
          "image": "python:3.8.11-slim"}}, "inputs": [{"name": "a", "type": "Float"},
          {"name": "b", "type": "Float"}], "name": "add_op", "outputs": [{"name":
          "Output", "type": "Float"}]}', pipelines.kubeflow.org/component_ref: '{}',
        pipelines.kubeflow.org/arguments.parameters: '{"a": "{{inputs.parameters.add-op-4-Output}}",
          "b": "{{inputs.parameters.add-op-5-Output}}"}'}
  - name: calculation-pipeline
    inputs:
      parameters:
      - {name: a}
      - {name: b}
    dag:
      tasks:
      - name: add-op
        template: add-op
        arguments:
          parameters:
          - {name: a, value: '{{inputs.parameters.a}}'}
      - name: add-op-2
        template: add-op-2
        arguments:
          parameters:
          - {name: b, value: '{{inputs.parameters.b}}'}
      - name: add-op-3
        template: add-op-3
        dependencies: [add-op, add-op-2]
        arguments:
          parameters:
          - {name: add-op-2-Output, value: '{{tasks.add-op-2.outputs.parameters.add-op-2-Output}}'}
          - {name: add-op-Output, value: '{{tasks.add-op.outputs.parameters.add-op-Output}}'}
      - name: add-op-4
        template: add-op-4
        dependencies: [add-op-3]
        arguments:
          parameters:
          - {name: a, value: '{{inputs.parameters.a}}'}
          - {name: add-op-3-Output, value: '{{tasks.add-op-3.outputs.parameters.add-op-3-Output}}'}
      - name: add-op-5
        template: add-op-5
        dependencies: [add-op-3]
        arguments:
          parameters:
          - {name: add-op-3-Output, value: '{{tasks.add-op-3.outputs.parameters.add-op-3-Output}}'}
          - {name: b, value: '{{inputs.parameters.b}}'}
      - name: add-op-6
        template: add-op-6
        dependencies: [add-op-4, add-op-5]
        arguments:
          parameters:
          - {name: add-op-4-Output, value: '{{tasks.add-op-4.outputs.parameters.add-op-4-Output}}'}
          - {name: add-op-5-Output, value: '{{tasks.add-op-5.outputs.parameters.add-op-5-Output}}'}
  arguments:
    parameters:
    - {name: a, value: '2'}
    - {name: b, value: '8'}
  serviceAccountName: pipeline-runner