Provide the ability to exclude a code block from coverage

[xqt]

Excluding a code block
Having a greater code block it would be great to have aq change to disable a code block from coverage with a start end end token. Currently only a single line can be excluded or code blocks within a clause. For example either the whole debug clause can be excluded but not the last two statements

This excludes the the whole if debug clause

a = my_function1()
if debug:   # pragma: no cover
    msg = "blah blah"
    log_message(msg, a)
    b = my_function2()

but I want to exclude the latest two statements (in practice these can be a lot of statemens). This can be done by excluding every line like

a = my_function1()
if debug: 
    msg = "blah blah"
    log_message(msg, a)   # pragma: no cover
    b = my_function2()   # pragma: no cover

but this may lead to a lot of such pragma: no cover command or a senseless clause must be used like

a = my_function1()
if debug: 
    msg = "blah blah"
    if True:   # pragma: no cover
        log_message(msg, a)
        b = my_function2()

start/end command as proposal
A start/end command can be introduced to solve this issue like pragma: no cover start and pragma: no cover stop or shorter no cover: start and no cover: stop or something like that. Instead of no cover: stop command a no cover: end command can be implemented as stop command. The code can then be excluded with

a = my_function1()
if debug: 
    msg = "blah blah"
    # no cover: start
    log_message(msg, a)
    b = my_function2()
    # no cover: stop

Other implementations as a sample
Coverage for Dart language support such block exclusion: (https://github.com/dart-lang/coverage)

[nedbat]

Help me understand your situation. In this code:

a = my_function1()
if debug: 
    msg = "blah blah"
    # no cover: start
    log_message(msg, a)
    b = my_function2()
    # no cover: stop

How would the msg = line be executed, but the log_message() line would not? Why do we need to exclude a block of lines adjacent to other executed lines?

[devdanzin]

Maybe in cases like:

a = my_function1()
if debug: 
   msg = "blah blah"
   if a is None:  # common path
     return my_function3()
   # no cover: start
   log_message(msg, a)
   b = my_function2()
   return b # no cover: stop

Or even:

def main():
  if not DEBUG:
    sys.exit()

if __name__ == "__main__":
  main()
  from debug import show_info  # no cover: start
  show_info()  # no cover: stop

So it may make sense after some way of exiting the normal flow of execution.

This means the end marker wouldn't be strictly necessary if the exclusion ended automatically on block end. But it might be useful to, e.g., temporarily mark a couple of blocks for exclusion.

[boxed]

You can do this like this:

if True:  # pragma: no cover
    a()
    b()
    c()

[nedbat]

As of commit 1fe897d, you can do this with a multi-line exclusion regex:

[report]
exclude_also =
    # no cover: start(?s:.)*?# no cover: stop

[nedbat]

This is now released as part of coverage 7.6.0.