Partial function application with the original docstring in Python?

Question

For partial function application, I know there are several ways to do that in Python. However, they seems not to preserve the original function's docstring.

Take functools.partial as example:

from functools import partial

def foo(a, b, c=1):
    """Return (a+b)*c."""
    return (a+b)*c

bar10_p = partial(foo, b=10)
print bar10_p.__doc__

partial(func, *args, **keywords) - new function with partial application 
of the given arguments and keywords.

Let's try fn.py:

from fn import F

def foo(a, b, c=1):
    """Return (a+b)*c."""
    return (a+b)*c

bar10_F = F(foo, b=10)
print bar10_F.__doc__

Provide simple syntax for functions composition
(through << and >> operators) and partial function
application (through simple tuple syntax).

Usage example:

>>> func = F() << (_ + 10) << (_ + 5)
>>> print(func(10))
25
>>> func = F() >> (filter, _ < 6) >> sum
>>> print(func(range(10)))
15

Is there any Python package/module providing partial application with preserved docstring?

UPDATE

As @Kevin and @Martijn Pieters mentioned, the function signature has changed such that it is not suggested to stick to the original function's docstring. I realized that I'm looking for an updated docstring with something like foo() with a default b value of 10 (Thanks for Kevin's simple but direct example.).

Answer 1

__doc__ is writable, on partial objects as well as on functions; simply copy it over:

bar10_p = partial(foo, b=10)
bar10_p.__doc__ = func.__doc__

or use the functools.update_wrapper() function to do the copying for you; it'll copy a few other pieces of metadata for you too:

from functools import update_wrapper

bar10_p = partial(foo, b=10)
update_wrapper(bar10_p, foo)

Answer 2

Just write a new __doc__.

bar10_p = partial(foo, b=10)
bar10_p.__doc__ = """foo() with a default b value of 10.

See foo().

"""

Your function has a different interface from the original, so it should not copy the docstring exactly.

Answer 3

With makefun you can do it:

from makefun import partial

def foo(a, b, c=1):
    """Return (a+b)*c."""
    return (a + b) * c

bar10_p = partial(foo, b=10)

assert bar10_p(0) == 10
assert bar10_p(0, c=2) == 20 
help(bar10_p)

It yields:

Help on function foo in module makefun.tests.test_so:

foo(a, c=1)
    <This function is equivalent to 'foo(a, c=1, b=10)', see original 'foo' doc below.>
    Return (a+b)*c.

Note that if you have any comment on how the docstring should be updated, do not hesitate to propose an issue on the git repo !

(I'm the author by the way)

Answer 4

Partial has access to func method which is the original function. So through original function, you have access to original function docstring.

Try this:

from math import cos
from functools import partial

cos_partial = partial(cos, 0.5)
print(cos_partial.func.__doc__)