How to use the planemo.options function in planemo

@options.report_xunit()
@command_function
def cli(ctx, paths, **kwds):
    """diff between local repository and Tool Shed.

    By default, this will produce a diff between this repository and what
    would be uploaded to the Tool Shed with the `shed_upload` command - but
    this command can be made to compare other combinations of repositories.
    Here are some examples

    \b
        $ # diff for this repository and the main Tool Shed
        $ planemo shed_diff
        $ # diff for this repository and the test Tool Shed
        $ planemo shed_diff --shed_target testtoolshed
        $ # diff for the test Tool Shed and main Tool Shed
        $ planemo shed_diff --shed_target_source testtoolshed

@options.required_tool_arg()
@options.required_job_arg()
@options.galaxy_serve_options()
@options.galaxy_cwl_root_option()
@options.cwl_conformance_test()
@click.option(
    "--cwl_engine",
    type=click.Choice(["galaxy", "cwltool"]),
    default="galaxy",
    help=("Select an engine to run CWL job using, defaults to Galaxy "
          "but the CWL reference implementation cwltool and be selected "
          "also.")
)
@pass_context
def cli(ctx, path, job_path, **kwds):
    """Planemo command for running CWL tools and jobs.

@options.optional_project_arg(exists=None)
@click.option(
    '--template',
    default=None
)
@command_function
def cli(ctx, path, template=None, **kwds):
    """(Experimental) Initialize a new tool project.

    This is only a proof-of-concept demo right now.
    """
    if template is None:
        warn("Creating empty project, this function doesn't do much yet.")
    if not os.path.exists(path):
        os.makedirs(path)
    if template is None:
        return

@options.required_tool_arg()
@click.option(
    '--from_tag',
    is_flag=True,
    help=(
        "Treat the tool's Docker container identifier as a locally cached tag."
    )
)
@click.option(
    '--shell',
    default="/bin/bash",
    help="Shell to launch in container (defaults to /bin/bash)."
)
@options.docker_cmd_option()
@options.docker_sudo_option()
@options.docker_sudo_cmd_option()
@options.docker_host_option()

@options.required_job_arg()
@click.option('--no_container', is_flag=True, default=False)
@click.option('outdir', '--output_dir', type=click.Path())
@click.option('basedir', '--base_dir', type=click.Path(), default=".")
@command_function
def cli(ctx, path, job_path, **kwds):
    """This compiles simple common workflow language workflows to a shell
    script.
    """
    to_script(ctx, path, job_path, **kwds)
    return 0

@options.recursive_option()
@options.mulled_options()
@options.conda_ensure_channels_option()
@command_function
def cli(ctx, paths, **kwds):
    """Build containers for specified tools.

    Supplied tools will be inspected for referenced requirement packages. For
    each combination of requirements a "mulled" container will be built. Galaxy
    can automatically discover this container and subsequently use it to run
    or test the tool.

    For this to work, the tool's requirements will need to be present in a known
    Conda channel such as bioconda (https://github.com/bioconda/bioconda-recipes).
    This can be verified by running ``planemo lint --conda_requirements`` on the
    target tool(s).
    """

@options.skip_option()
@options.lint_xsd_option()
@options.recursive_option()
@click.option(
    "--urls",
    is_flag=True,
    default=False,
    help="Check validity of URLs in XML files",
)
@click.option(
    "--doi",
    is_flag=True,
    default=False,
    help="Check validity of DOIs in XML files",
)
@click.option(
    "--conda_requirements",

@options.profile_database_options()
@options.docker_config_options()
@command_function
def cli(ctx, profile_name, **kwds):
    """Delete a profile."""
    profiles.delete_profile(ctx, profile_name, **kwds)
    print("Profile deleted.")

@options.shed_skip_metadata()
@command_function
def cli(ctx, paths, **kwds):
    """Update Tool Shed repository.

    By default this command will update both repository metadata
    from ``.shed.yml`` and upload new contents from the repository
    directory.

    \b
        % planemo shed_update

    This will update the main tool shed with the repository defined
    by a ``.shed.yml`` file in the current working directory. Both
    the location of the ``.shed.yml`` and the tool shed to upload to
    can be easily configured. For instance, the following command can
    be used if ``.shed.yml`` if contained in ``path/to/repo`` and the