How to simplfy the YAML pipline configuration?

[Hoohaha]

Hi,

Seems the steps require name filed to specify the step type.
Is possible to use key words directly without name in step, like github actions YAML

Example:

steps:
  - echoMe: o hai!
  - cmd: python--version

[yaythomas]

Thanks for the suggestion @Hoohaha!

I’m all for a more succinct/compressed step syntax, and what you’re suggesting looks great!

There’re a few problems, though. . .
pypyr tries very hard to be very extensible, and very simply so - so you can make a custom step very easily by putting a def run_step(context): function into any given python module.

This means that any given step is responsible in itself for deciding what to do with the context - i.e the in variables.
Importantly, there can be more than one input for a step, and many steps take more than one input argument.

E.g with cmd, if you want to pass save and bytes in addition to the cmd string:

- name: pypyr.steps.cmd
  in:
    cmd:
        run: python --version
        save: True
        bytes: True

So as it stands it's not really easily feasible for the pypyr run-time to know what is meant by:

- cmd: python --version

1. Which argument does python --version belong to? run or save or bytes?
2. cmd could refer to ./cmd.py (i.e a custom python module created by the user),
   it could also refer to pypyr.steps.cmd (the built-in step).

It's maybe possible to make 1 work, but it's a bit involved and I'll have to
think about it a bit more. (In short, the pypyr runtime would have to treat a
1-item dict/map step as a special case, where the key is the step-name and the
value is the default input that'd pypyr would have to inject into context - it's
then up to the step to interpret that input - but this won't work universally for all steps.)

For 2. - we could maybe do a double look-up - 1st check if the bare cmd resolves
in the current directory, if not, see if pypyr.steps.x (in this case x = cmd) resolves.

All of this would have to keep backwards compatibility.

I’m going to move this from issues to the discussions board, feel very free to respond there!
Interested to hear ideas! If this turns into something concrete enough to be a
work item I'll create task here.

[blaisep]

I love the answer. It helps me understand pypyr so much more.
I think it reminds me of Ansible. I wonder if we could use molecule for testing pipelines?
https://www.ansible.com/blog/developing-and-testing-ansible-roles-with-molecule-and-podman-part-2

[yaythomas]

I've not done so myself. . . I guess you could. If part of your ansible playbooks invoke pypyr to do more pipeline-y workflow stuff, then yes, certainly molecule could be a handy way of provisioning & testing!

If you just want to test a pypyr pipeline in isolation I guess you could still use molecule if you're willing to override all the ansible specific stuff, but I don't know to what extent it would still be sensible to use molecule if ansible is not in the mix?

For pypyr internally, I generally test end-to-end scenarios with good ol' pytest - for example here https://github.com/pypyr/pypyr/blob/main/tests/integration/pypyr/pipelinerunner_int_test.py