Clean up and improve the metadata used in the setup.py file.

• dependency inclusion from requirements file
• GPG signing using code signing key
• list signing key somewhere like keybase and linked to from pypy
• deploy runbook-1.0 package to test pypy
• deploy runbook-1.0 package to prod pypy

• better spacing between tasks, around repeatable tasks in a resume flow
• reduce wait time for long text, consider a non-linear curve
• add a 'done' message to the screen output
• consider printing the book name in screen output

support scrolling when using runbook show (https://stackoverflow.com/a/3306399)

Support iterating over a runbook object, yielding steps. Maybe iterate to
list, and generator.next to do step completion with logging and prompts

Consider supporting the notion of Acceptance Criteria, or otherwise answering the question "How do you know it's done?" for each step of a runbook.

something like...

Did you do the thing?
  > yes

Are you sure? You can perform the following action to confirm:
  > Make a text record in the new DNS zone and use dig to request it.
  > dig xyz.potatosalad.com TXT
  > It should return the expected text value

Were you able to confirm?
  > yes

attach cryptographic signatures to completed steps in the log file to make enhanced verification possible

relates to #40

• remove 'dynamic documentation' return string
• add method parameter docs
  • captures either a string or a callable
  • (turn strings into callables)
• add annotation @with_docs which takes a similar arguments
  • string or callable as sole argument
  • annotation must be imported from another module, not in the immediate
    namespace
  • ensure decorated steps are still able to be located within the class

☀ This issue was created by email; some cleanup may be required.

this file was generated, it is used for input, etc.

In theory, since there are no dependencies this can use an un-license.

• in setup.py
• in readme
• in license file
• whatever github needs to show it

support logging to various other places, multiple loggers, etc

better translation of XyzABCd class names to log names, which is somewhat intractable. Consider: RESTAPIHelper, RestAPIHelper, RestApiHelper, etc.

Convenience method to render the markdown file into a terminal format.

The current implementation sorts methods by class hierarchy and the line number of the file in which they were defined. This works ok, but breaks down when defining methods on a class outside of the class body.

There may or may not be a way to support this kind of behavior. A subclass init hook or other hook which is called when a member is defined could help if it triggers in the right order.

Use the docstring of the class as a way to declare a large textual preamble to a book.

#7 defines a decorator annotation that can be used to customize a step. In theory it would be possible to instead use keyword arguments with defaults to decorate the methods.

This decorated step

@step(repeatable=True)
def second_step():
    pass

could instead be written as

def second_step(repeatable=True):
    pass

• name
• repeatable
• skippable
• critical

supports things like

• custom step names for a method
• custom step behavior (skippable, etc)

• decorator function
• name
• repeatable
• skippable
• critical
• timeout ?

Set up basic unit testing.

• test framework
• tests for step ordering
• tests for step repetition
• tests for inheritence

Some feedback based on others' experiences so far.

• maybe remark about supported input options on the first encounter
• add ['yeah+', ''yep+', 'nah+', 'affirmative', 'negative'] to options
• support looser acceptance when starts with an option
• consider 4 spaces instead of tabs for prompt text (too indented)
• different interpretations of 'done', so consider altering the prompt text to read 'Did you successfully do the thing?"

Support for rendering basic markdown to styled terminal text would be nice. The step descriptions would benefit from being able to leverage markdown, such as for bulleted lists, links, title text, bold and italic text, etc.

setup.py or whatever the kids are using these days

new step attribute timeout that limits how long to wait for a step to be completed before giving up or failing

There aren't many prompts or error texts in the code. It should be possible to implement localized version of these messages without much effort. Consider supporting localization and include Spanish and German as the initial offerings.

requires #14 first for full unicode support

Given classes A, B, and C(A, B) resolve the order of steps as A, B, and C.

• add missing file (setup.py?)
• make a script for deploying

• seems like every task after resuming is prefixed with 'resuming xxx'
• text for a repeated task inside of a group of resumed tasks

In the path towards automation, the idea of the runbook is to slowly swap out individual steps / methods in the class for automated actions, eventually cutting out the humans entirely. To facilitate this we need the concept of an automated step, one which does not prompt but performs an action and logs it.

Considerations include acceptance criteria, whether the user should confirm the action or just let it happen, repeatability, etc. Also right now the methods are invoked to return dynamic doc strings, so this behavior might be in conflict if the method has to run.

Some possible implementations:

def _deploy_cf_stack():
    pass

def deploy_cf_stack(action='_deploy_cf_stack'):
    """
    Deploys the CloudFormation stack with parameters
    derived from the previous steps.
    """

def deploy_cf_stack(auto=True):
    """
    Deploys the CloudFormation stack with parameters
    derived from the previous steps.
    """
    def action_fn():
        self.helper.deployStack()

    return StepInfo(description="dynamic docs!", action=action_fn)

def deploy_cf_stack(with_action):
    """
    Deploys the CloudFormation stack with parameters
    derived from the previous steps.
    """
    def action_fn():
        self.helper.deployStack()
    
    with_action(action_fn)
    return "dynamic docs"

def deploy_cf_stack(action):
    """
    Deploys the CloudFormation stack with parameters
    derived from the previous steps.
    """
    @action
    def do_deploy():
        self.helper.deployStack()
    
    return "dynamic docs"

GitHub tasks markdown format

• a cprint("some text") method
• output colors by default
• command line option to disable colors (#5 seems relevant)

• add example of import unquietcode.tools.runbook.Runbook
• step attributes
• inheritence
• license info
• output file format
• using existing log files
• module shortcuts (new / show)

one or two solid examples

Support for responses that start with an accepted value but then deviate. Here is an example interaction that went poorly:

Did you do the thing?

    -> yes, and it kind of worked

Invalid response.
```

So when checking responses this could have matched 'yes', and then the rest would be captured and placed in the log file, but still be valid as a yes answer.

do instead something like:

existing_step_names = {}

for step in steps
  if name in existing_names
    skip

this handles the case of reordering better, while preserving additions and subtractions

For longer pauses, enter to skip the wait. Appears after a few seconds.

• ensure unicode works fine
• try to get emojii working as well
• consider sparse use of some unicode symbols in the log file

relating steps together so that they are all or none