patchy 3.1.0

patch(func, patch_text)

Apply the patch patch_text to the source of function func. func may be either a function, or a string providing the dotted path to import a function.

If the patch is invalid, for example the context lines don’t match, ValueError will be raised, with a message that includes all the output from the patch utility.

Note that patch_text will be textwrap.dedent()’ed, but leading whitespace will not be removed. Therefore the correct way to include the patch is with a triple-quoted string with a backslash - """\ - which starts the string and avoids including the first newline. A final newline is not required and will be automatically added if not present.

Example:

import patchy


def sample():
    return 1


patchy.patch(
    sample,
    """\
    @@ -2,2 +2,2 @@
    -    return 1
    +    return 2""",
)

print(sample())  # prints 2

mc_patchface(func, patch_text)

An alias for patch, so you can meme it up by calling patchy.mc_patchface().

unpatch(func, patch_text)

Unapply the patch patch_text from the source of function func. This is the reverse of patch()ing it, and calls patch --reverse.

The same error and formatting rules apply as in patch().

Example:

import patchy


def sample():
    return 2


patchy.unpatch(
    sample,
    """\
    @@ -2,2 +2,2 @@
    -    return 1
    +    return 2""",
)

print(sample())  # prints 1

temp_patch(func, patch_text)

Takes the same arguments as patch. Usable as a context manager or function decorator to wrap code with a call to patch before and unpatch after.

Context manager example:

def sample():
    return 1234


patch_text = """\
    @@ -1,2 +1,2 @@
     def sample():
    -    return 1234
    +    return 5678
    """

with patchy.temp_patch(sample, patch_text):
    print(sample())  # prints 5678

Decorator example, using the same sample and patch_text:

@patchy.temp_patch(sample, patch_text)
def my_func():
    return sample() == 5678


print(my_func())  # prints True

replace(func, expected_source, new_source)

Check that function or dotted path to function func has an AST matching expected_source, then replace its inner code object with source compiled from new_source. If the AST check fails, ValueError will be raised with current/expected source code in the message. In the author’s opinion it’s preferable to call patch() so your call makes it clear to see what is being changed about func, but using replace() is simpler as you don’t have to make a patch and there is no subprocess call to the patch utility.

Note both expected_source and new_source will be textwrap.dedent()’ed, so the best way to include their source is with a triple quoted string with a backslash escape on the first line, as per the example below.

If you want, you can pass expected_source=None to avoid the guard against your target changing, but this is highly unrecommended as it means if the original function changes, the call to replace() will continue to silently succeed.

Example:

import patchy


def sample():
    return 1


patchy.replace(
    sample,
    """\
    def sample():
        return 1
    """,
    """\
    def sample():
        return 42
    """,
)

print(sample())  # prints 42