The simplest solution for single arguments or options seems to be to just create a variable ARG = click.option(...) and then use @ARG as a decorator of the command function.

Applying multiple opts/args at once involves creating a decorator factory or a callable class. This is the cleanest solution I found, credits go to @altendky and @SnoopJ from #python channel on Libera IRC:

from typing import List, Callable

import attr
import click

from click.decorators import FC

options = [
    click.option("-a"),
    click.option("-b"),
]


# Solution 1: decorator factory
def multi_decorator(options: List[Callable[[FC], FC]]) -> Callable[[FC], FC]:
    def decorator(f: FC) -> FC:
        for option in reversed(options):
            f = option(f)

        return f

    return decorator


@click.command()
@multi_decorator(options)
def cmd1(a, b):
    pass


# Solution 2: callable class
@attr.s
class MultiDecorator:
    options: List[Callable[[FC], FC]] = attr.ib(factory=list)

    def __call__(self, f: FC):
        for option in reversed(self.options):
            f = option(f)

        return f


@click.command()
@MultiDecorator(options)
def cmd2(a, b):
    pass


if __name__ == "__main__":
    from click.testing import CliRunner
    runner = CliRunner()

    print(runner.invoke(cmd1, ["--help"]).output)
    print(runner.invoke(cmd2, ["--help"]).output)

If you want to test or improve this, head over to https://replit.com/@ldericher/multidecorator.

import sys
import click
import pandas as pd
from sklearn import metrics
@click.command()

# @click.option('--filename')
## @click.argument('result.csv', type=click.Path(exists=True))
@click.argument('filename', type=click.Path(exists=True))
def main(filename):

    df = pd.read_csv(filename)
    y_test = df["actual"].values
    y_pred = df["predicted"].values

    print('R Squared: ' +  str(metrics.r2_score(y_test, y_pred)))
    
if __name__ == '__main__':
    # sys.argv = ['',  '--filename', 'result.csv']
    sys.argv = ['',  'result.csv']
    main()

If you don't insist on passing something that looks like a list, but simply want to pass multiple variadic arguments, you can use the multiple option.

From the click documentation

@click.command()
@click.option('--message', '-m', multiple=True)
def commit(message):
    click.echo('\n'.join(message))

$ commit -m foo -m bar
foo
bar

One way that I have managed to achieve this behaviour was by actually using arguments as below. I'll post this as a workaround, while I try to see if it could be done with an option, and I'll update my post accordingly

@click.command(context_settings={"ignore_unknown_options": True})
@click.argument("options", nargs=-1)
def myscript(options):
    option = False
    if options is ():
        option = False
    if '-o' in options or '--option' in options:
        option = True
    if len(options) > 1:
        option = options[1]
    print(option)

Later Edit Using an option, I have managed to achieve this by adding an argument to the command definition.

@click.command()
@click.option('-o', '--option', is_flag=True, default=False, is_eager=True)
@click.argument('value', nargs=-1)
def myscript(option, value):
    if option and value != ():
        option = value[0]
    print(option)

The nargs can be removed if you only expect at most one argument to follow, and can be treated as not required.

@click.command()
@click.option('-o', '--option', is_flag=True, default=False, is_eager=True)
@click.argument('value', required=False)
def myscript(option, value=None):
    if option and value is not None:
        option = value
    print(option)

It might also be possible by putting together a context generator and storing some state, but that seems the least desirable solution, since you would be relying on the context storing your state.

The Forwarding Unknown Options section in the documentation covers this use case. You should be able to write something like this:

@click.command(context_settings=dict(
    ignore_unknown_options=True,
))
@click.option("--port", type=int)
@click.argument("args", nargs=-1, type=click.UNPROCESSED)
def main(port, args):
    call_the_wrapped_program(port=port, args=args)

This is possible since Click 4.0. You need to tell click to ignore the unknown option, and that you want the options gathered up and passed in. Here is your example with the relevant changes made.

Code:

@click.group()
@click.option('--arg')
def cli(arg):
    click.echo('cli arg: %s' % arg)
    pass

@cli.command(context_settings=dict(
    ignore_unknown_options=True,
    help_option_names=[],
))
@click.argument('script')
@click.argument('args', nargs=-1, type=click.UNPROCESSED)
def run(script, args):
    click.echo('script: %s' % script)
    click.echo(args)

Test:

cli('--arg 3 run foo.py --arg 5 arg1 --arg2 --arg 4 --help'.split())

Produces:

cli arg: 3
script: foo.py
('--arg', '5', 'arg1', '--arg2', '"--arg', '4"', '--help')

(Source)