Class based patch API

[kai3341]

Description

What do you think about API like this:

from patchy import patch
from typing import Callable

class Patch:
    target: Callable

    def __init_subclass__(cls) -> None:
        diff_u = cls.__doc__.strip("\n")
        patch(cls.target, diff_u)

And usage example:

class PatchHandleUpdates(Patch):
    """
    @@ -1,8 +1,8 @@
     async def handle_updates(self, updates):
         if isinstance(updates, (raw.types.Updates, raw.types.UpdatesCombined)):
             is_min = any((
    -            await self.fetch_peers(updates.users),
    -            await self.fetch_peers(updates.chats),
    +            await self.fetch_peers__users(updates.users),
    +            await self.fetch_peers__chats(updates.chats),
             ))

             users = {u.id: u for u in updates.users}
    """

    target = Client.handle_updates

TODO:

• Maybe add explicit patch apply / rollback
• • It would require explicit methods apply and rollback instead of my implementation
• Maybe something else?
• • Yes. Ability to add any name into globals. It require API change

[kai3341]

Or another example with #431

from common.patcher import Patch
from patchy import api


class PatchSetSource(Patch):
    """
    @@ -102,11 +102,18 @@

         # Compile and retrieve the new Code object
         localz: dict[str, Any] = {}
    +
    +    globalz = dict(func.__globals__)
    +
    +    for cell in func.__closure__ or ():
    +        cell_contents = cell.cell_contents
    +        globalz.update(cell_contents.__dict__)
    +
         new_code = cast(CodeType, _compile(new_source))

         exec(
             new_code,
    -        dict(func.__globals__),
    +        globalz,
             localz,
         )
         new_func = localz["__patchy_freevars__"]()
    """

    target = api._set_source

The most funny that I patched patchy via patchy

[adamchainz]

Thanks for the suggestion, but I do not like the proposal. Creating a class is not something a reader would expect to change another class/function. Sticking with a function call - patch() - is the clearest syntax.

[kai3341]

@adamchainz I agree that applying patch on class creation moment was bad idea. Firstly, it's my working prototype, it already works and solve my problems. And because it was my almost first idea I asked your oppinion about it. Then I suggested some improvements. So, I'll make a copy of my questions and ideas which are in the first message:

• Maybe add explicit patch apply / rollback
• • It would require explicit methods apply and rollback instead of my implementation
• Maybe something else?
• • Yes. Ability to add any name into globals. It requires API change

So, the first point is exactly about removing applying of patch on class creation moment. Bonus is methods apply and rollback are bound to the same object -- it looks really handy

Finally -- maybe reopen the issue and I'll implement these ideas? Maybe anything else?

[adamchainz]

I don't want to add a new API using class syntax.

You can already use temp_patch as a context manager which gives you an object with apply/rollback like functions (__enter__ and __exit__):

patcher = temp_patch(...)

with patcher:
    # patched during this block
    ...

patcher.__enter__()  # apply patch
patcher.__exit__(None, None, None)  # unapply patch