Line break within function declaration disables exclusion of the function body

[fuine]

.coveragerc file:

[report]
exclude_lines =
    long_function_name.+

Code:

def long_function_name(some_long_argument,  another_long_argument):
    pass

This setup works and results in the following report:

Name      Stmts   Miss  Cover   Missing
---------------------------------------
file.py       0      0   100%

However, if a line break is introduced between arguments and the second line gets indented in compliance to the PEP-8:

def long_function_name(some_long_argument,
                       another_long_argument):
    pass

Then the body isn't excluded anymore:

Name      Stmts   Miss  Cover   Missing
---------------------------------------
file.py       1      1     0%   4

I'm not really sure if this is a bug, but I haven't found a way to bypass this behaviour - I would like the whole function excluded, regardless of the formatting of function arguments. Is this possible?

[nedbat]

Hmm, there is logic in coverage.py to make multi-line statements act as a single unit. I'll need to look into why that isn't happening in this case.

Can you tell me more about your actual code and configuration? Why exclude functions based on their name?

[tailaiw]

I ran into exactly the same issue. So we have an update on it? Thanks!

I'm using python3.8, coverage 5.0.3, pytest 5.3.5, and pytest-cov 2.8.1.

Here is my main.py code

def my_func(
    super_long_input_argument_0=0,
    super_long_input_argument_1=1,
    super_long_input_argument_2=2):
    pass

def my_func_2(super_long_input_argument_0=0, super_long_input_argument_1=1, super_long_input_argument_2=2):
    pass

def test_main():
    assert 1 == 1

Here is my .coveragerc

[report]
show_missing = True
exclude_lines =
    def my_func
    def my_func_2

And here is the output running pytest main.py --cov=.

platform linux -- Python 3.8.1, pytest-5.3.5, py-1.8.1, pluggy-0.13.1
rootdir: blablabla
plugins: cov-2.8.1
collected 1 item                                                                                                                                                                            

main.py .                                                                                                                                                                             [100%]

----------- coverage: platform linux, python 3.8.1-final-0 -----------
Name      Stmts   Miss  Cover   Missing
---------------------------------------
main.py       3      1    67%   5

[FateScript]

Gently ask, any progress of this issue?
I work around this problem by using ast module and expect a more elegent way, thanks.

[nedbat]

@FateScript Thanks for chiming in. Can you say more about how you are using the ast module?

[FateScript]

@FateScript Thanks for chiming in. Can you say more about how you are using the ast module?

@nedbat My idea is simple, if a function like

def long_function_name(some_long_argument,
                       another_long_argument):
    # python code here

is marked as executed, the lineno of def long_function_name(some_long_argument, will be recorded.
I get the lineno and determine if it's a definition of function, and if it is, my target is to parse a function like

def long_function_name(some_long_argument,
                       another_long_argument):
    pass

Here is a sketch of my code:

def complete_definition(code: List[str], executed_lineno: int) -> List[int]:
    src_code = code[executed_lineno-1]  # -1 because lineno starts from 1
    select_lineno = [executed_lineno]
    if is_function_def(src_code):
        func_suffix = (count_blank_prefix(src_code) + 4) * " " + "pass"  # indent length is 4 here
        while True:
            if pass_ast_parse(src_code + func_suffix):
                break
            # add next line of code
            executed_lineno += 1
            select_lineno.add(executed_lineno)
            src_code = src_code + "\n" + code[executed_lineno-1]
    return select_lineno

The method might not be perfect but somehow fix my issue.
May it help someone.

[nedbat]

One solution to this is to use pragma comments instead of omit settings:

def my_func(
    super_long_input_argument_0=0,
    super_long_input_argument_1=1,
    super_long_input_argument_2=2):     # pragma: no cover
    pass

You'll need to be sure your exclude_lines setting still includes "pragma: no cover", or use the newer [report] exclude_also setting for your custom exclusions:

[report]
show_missing = True
exclude_also =
    def my_func
    def my_func_2

[FateScript]

@nedbat Thanks for your solution : )
However, I'm writing a tracing tools with coveragepy to trace code execution in packages like pytorch or langchain, so I couldn't modify the source code of those packages and I'm not sure which function will be executed.

[nedbat]

@FateScript this gets more and more interesting! Can you say more about why you want to omit certain functions within pytorch/langchain?

[FateScript]

@nedbat The tracing tool will show users what code is executed for a specific function. However, when import a package likeimport torch, it will introduce some functions that might to omit and only a small part of code is needed.
For example, if someone wonder what code is executed when running

x = MyModule()
x(1)

The tracing tool will show something like the following

filename: path to torch.nn.module

class Module():
    def __init__(self, xxx):
        # code of init
    def __call__(self, xxx):
        # code of init

In this case, class Module, __init__ , __call__ is executed when import torch and code of __init__, __call__ is executed when running my code. So I need to omit some function when import torch and I couldn't list them all before executing.
Looking forward to your suggestions or constructive ideas. Thanks : )

[altendky]

My use case, present in the example in #1691, is to exclude my benchmark tests since they are executed in a separate test run without coverage measurement. They all use a common pytest fixture so that would be what I try to exclude.