We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Memory leaks in Windows
**Describe the bug**
Unfortunately, it seems like there are memory leaks issues in the Windows implementation of toga

**To Reproduce**
Steps to reproduce the behavior:
1. install memory profiler, briefcase and matplotlib using `pip install memory_profiler briefcase matplotlib`
2. Go to the Box example directory (or any other example for that matter)
3. Run `mprof run --include-children briefcase dev`
4. Click some buttons and wait for a few seconds
5. Exit the program
6. run `mprof plot` and see the memory leak

![memory_leak](https://user-images.githubusercontent.com/19425795/96552884-11b31500-12bd-11eb-8c31-78aaeab5ca88.png)

**Environment:**
 - Operating System: Windows 10
 - Python version: python 3.8
 - Software versions:
   - Briefcase: latest
   - Toga: latest


--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `src/winforms/toga_winforms/libs/proactor.py`
Content:
```
1 import asyncio
2 import sys
3 import threading
4 from asyncio import events
5 
6 from .winforms import Action, Task, WinForms, user32
7 
8 
9 class AsyncIOTickMessageFilter(WinForms.IMessageFilter):
10     """
11     A Winforms message filter that will catch the request to tick the Asyncio
12     event loop.
13     """
14     __namespace__ = 'System.Windows.Forms'
15 
16     def __init__(self, loop, msg_id):
17         self.loop = loop
18         self.msg_id = msg_id
19 
20     def PreFilterMessage(self, message):
21         print('ping', message)
22         if message.Msg == self.msg_id:
23             print("asyncio tick message!!")
24             self.loop.run_once_recurring()
25             return True
26         # print("Filter message", message)
27         return False
28 
29 
30 class WinformsProactorEventLoop(asyncio.ProactorEventLoop):
31     def run_forever(self, app_context):
32         """Set up the asyncio event loop, integrate it with the Winforms
33         event loop, and start the application.
34 
35         This largely duplicates the setup behavior of the default Proactor
36         run_forever implementation.
37 
38         :param app_context: The WinForms.ApplicationContext instance
39             controlling the lifecycle of the app.
40         """
41         # Python 3.8 added an implementation of run_forever() in
42         # ProactorEventLoop. The only part that actually matters is the
43         # refactoring that moved the initial call to stage _loop_self_reading;
44         # it now needs to be created as part of run_forever; otherwise the
45         # event loop locks up, because there won't be anything for the
46         # select call to process.
47         if sys.version_info >= (3, 8):
48             self.call_soon(self._loop_self_reading)
49 
50         # Remember the application context.
51         self.app_context = app_context
52 
53         # Register a custom user window message.
54         self.msg_id = user32.RegisterWindowMessageA("Python asyncio tick")
55         # Add a message filter to listen for the asyncio tick message
56         # FIXME: Actually install the message filter.
57         # msg_filter = AsyncIOTickMessageFilter(self, self.msg_id)
58         # WinForms.Application.AddMessageFilter(msg_filter)
59 
60         # Setup the Proactor.
61         # The code between the following markers should be exactly the same as
62         # the official CPython implementation, up to the start of the
63         # `while True:` part of run_forever() (see BaseEventLoop.run_forever()
64         # in Lib/ascynio/base_events.py)
65         # === START BaseEventLoop.run_forever() setup ===
66         self._check_closed()
67         if self.is_running():
68             raise RuntimeError('This event loop is already running')
69         if events._get_running_loop() is not None:
70             raise RuntimeError(
71                 'Cannot run the event loop while another loop is running')
72         self._set_coroutine_origin_tracking(self._debug)
73         self._thread_id = threading.get_ident()
74         try:
75             self._old_agen_hooks = sys.get_asyncgen_hooks()
76             sys.set_asyncgen_hooks(
77                 firstiter=self._asyncgen_firstiter_hook,
78                 finalizer=self._asyncgen_finalizer_hook
79             )
80         except AttributeError:
81             # Python < 3.6 didn't have sys.get_asyncgen_hooks();
82             # No action required for those versions.
83             pass
84 
85         events._set_running_loop(self)
86         # === END BaseEventLoop.run_forever() setup ===
87 
88         # Rather than going into a `while True:` loop, we're going to use the
89         # Winforms event loop to queue a tick() message that will cause a
90         # single iteration of the asyncio event loop to be executed. Each time
91         # we do this, we queue *another* tick() message in 5ms time. In this
92         # way, we'll get a continuous stream of tick() calls, without blocking
93         # the Winforms event loop.
94 
95         # Queue the first asyncio tick.
96         self.enqueue_tick()
97 
98         # Start the Winforms event loop.
99         WinForms.Application.Run(self.app_context)
100 
101     def enqueue_tick(self):
102         # Queue a call to tick in 5ms.
103         Task.Delay(5).ContinueWith(Action[Task](self.tick))
104 
105     def tick(self, *args, **kwargs):
106         """
107         Cause a single iteration of the event loop to run on the main GUI thread.
108         """
109         # Post a userspace message that will trigger running an iteration
110         # of the asyncio event loop. This can't be done directly, because the
111         # tick() will be executing in a threadpool, and we need the asyncio
112         # handling to occur in the main GUI thread. However, by positing a
113         # message, it will be caught by the MessageFilter we installed on the
114         # Application thread.
115 
116         # The message is sent with:
117         # * HWND 0xfff (all windows),
118         # * MSG self.msg_id (a message ID in the WM_USER range)
119         # * LPARAM and WPARAM empty (no extra details needed; just tick!)
120         user32.PostMessageA(0xffff, self.msg_id, None, None)
121 
122         # FIXME: Once we have a working message filter, this invoke call
123         # can be removed.
124         # If the app context has a main form, invoke run_once_recurring()
125         # on the thread associated with that form.
126         if self.app_context.MainForm:
127             self.app_context.MainForm.Invoke(Action(self.run_once_recurring))
128 
129     def run_once_recurring(self):
130         """
131         Run one iteration of the event loop, and enqueue the next iteration
132         (if we're not stopping).
133 
134         This largely duplicates the "finally" behavior of the default Proactor
135         run_forever implementation.
136         """
137         # Perform one tick of the event loop.
138         self._run_once()
139 
140         if self._stopping:
141             # If we're stopping, we can do the "finally" handling from
142             # the BaseEventLoop run_forever().
143             # === START BaseEventLoop.run_forever() finally handling ===
144             self._stopping = False
145             self._thread_id = None
146             events._set_running_loop(None)
147             self._set_coroutine_origin_tracking(False)
148             try:
149                 sys.set_asyncgen_hooks(*self._old_agen_hooks)
150             except AttributeError:
151                 # Python < 3.6 didn't have set_asyncgen_hooks.
152                 # No action required for those versions.
153                 pass
154             # === END BaseEventLoop.run_forever() finally handling ===
155         else:
156             # Otherwise, live to tick another day. Enqueue the next tick,
157             # and make sure there will be *something* to be processed.
158             # If you don't ensure there is at least one message on the
159             # queue, the select() call will block, locking the app.
160             self.enqueue_tick()
161             self.call_soon(self._loop_self_reading)
162 
163 
164 # Python 3.7 changed the name of an internal wrapper function.
165 # Install an alias for the old name at the new name.
166 if sys.version_info < (3, 7):
167     WinformsProactorEventLoop._set_coroutine_origin_tracking = WinformsProactorEventLoop._set_coroutine_wrapper
168
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/src/winforms/toga_winforms/libs/proactor.py b/src/winforms/toga_winforms/libs/proactor.py
--- a/src/winforms/toga_winforms/libs/proactor.py
+++ b/src/winforms/toga_winforms/libs/proactor.py
@@ -100,7 +100,8 @@
 
     def enqueue_tick(self):
         # Queue a call to tick in 5ms.
-        Task.Delay(5).ContinueWith(Action[Task](self.tick))
+        self.task = Action[Task](self.tick)
+        Task.Delay(5).ContinueWith(self.task)
 
     def tick(self, *args, **kwargs):
         """
@@ -113,6 +114,9 @@
         # message, it will be caught by the MessageFilter we installed on the
         # Application thread.
 
+        if self.task:
+            self.task.Dispose()
+            del self.task
         # The message is sent with:
         # * HWND 0xfff (all windows),
         # * MSG self.msg_id (a message ID in the WM_USER range)
@@ -124,7 +128,10 @@
         # If the app context has a main form, invoke run_once_recurring()
         # on the thread associated with that form.
         if self.app_context.MainForm:
-            self.app_context.MainForm.Invoke(Action(self.run_once_recurring))
+            action = Action(self.run_once_recurring)
+            self.app_context.MainForm.Invoke(action)
+            action.Dispose()
+            del action
 
     def run_once_recurring(self):
         """

{"golden_diff": "diff --git a/src/winforms/toga_winforms/libs/proactor.py b/src/winforms/toga_winforms/libs/proactor.py\n--- a/src/winforms/toga_winforms/libs/proactor.py\n+++ b/src/winforms/toga_winforms/libs/proactor.py\n@@ -100,7 +100,8 @@\n \n     def enqueue_tick(self):\n         # Queue a call to tick in 5ms.\n-        Task.Delay(5).ContinueWith(Action[Task](self.tick))\n+        self.task = Action[Task](self.tick)\n+        Task.Delay(5).ContinueWith(self.task)\n \n     def tick(self, *args, **kwargs):\n         \"\"\"\n@@ -113,6 +114,9 @@\n         # message, it will be caught by the MessageFilter we installed on the\n         # Application thread.\n \n+        if self.task:\n+            self.task.Dispose()\n+            del self.task\n         # The message is sent with:\n         # * HWND 0xfff (all windows),\n         # * MSG self.msg_id (a message ID in the WM_USER range)\n@@ -124,7 +128,10 @@\n         # If the app context has a main form, invoke run_once_recurring()\n         # on the thread associated with that form.\n         if self.app_context.MainForm:\n-            self.app_context.MainForm.Invoke(Action(self.run_once_recurring))\n+            action = Action(self.run_once_recurring)\n+            self.app_context.MainForm.Invoke(action)\n+            action.Dispose()\n+            del action\n \n     def run_once_recurring(self):\n         \"\"\"\n", "issue": "Memory leaks in Windows\n**Describe the bug**\r\nUnfortunately, it seems like there are memory leaks issues in the Windows implementation of toga\r\n\r\n**To Reproduce**\r\nSteps to reproduce the behavior:\r\n1. install memory profiler, briefcase and matplotlib using `pip install memory_profiler briefcase matplotlib`\r\n2. Go to the Box example directory (or any other example for that matter)\r\n3. Run `mprof run --include-children briefcase dev`\r\n4. Click some buttons and wait for a few seconds\r\n5. Exit the program\r\n6. run `mprof plot` and see the memory leak\r\n\r\n![memory_leak](https://user-images.githubusercontent.com/19425795/96552884-11b31500-12bd-11eb-8c31-78aaeab5ca88.png)\r\n\r\n**Environment:**\r\n - Operating System: Windows 10\r\n - Python version: python 3.8\r\n - Software versions:\r\n   - Briefcase: latest\r\n   - Toga: latest\r\n\n", "before_files": [{"content": "import asyncio\nimport sys\nimport threading\nfrom asyncio import events\n\nfrom .winforms import Action, Task, WinForms, user32\n\n\nclass AsyncIOTickMessageFilter(WinForms.IMessageFilter):\n    \"\"\"\n    A Winforms message filter that will catch the request to tick the Asyncio\n    event loop.\n    \"\"\"\n    __namespace__ = 'System.Windows.Forms'\n\n    def __init__(self, loop, msg_id):\n        self.loop = loop\n        self.msg_id = msg_id\n\n    def PreFilterMessage(self, message):\n        print('ping', message)\n        if message.Msg == self.msg_id:\n            print(\"asyncio tick message!!\")\n            self.loop.run_once_recurring()\n            return True\n        # print(\"Filter message\", message)\n        return False\n\n\nclass WinformsProactorEventLoop(asyncio.ProactorEventLoop):\n    def run_forever(self, app_context):\n        \"\"\"Set up the asyncio event loop, integrate it with the Winforms\n        event loop, and start the application.\n\n        This largely duplicates the setup behavior of the default Proactor\n        run_forever implementation.\n\n        :param app_context: The WinForms.ApplicationContext instance\n            controlling the lifecycle of the app.\n        \"\"\"\n        # Python 3.8 added an implementation of run_forever() in\n        # ProactorEventLoop. The only part that actually matters is the\n        # refactoring that moved the initial call to stage _loop_self_reading;\n        # it now needs to be created as part of run_forever; otherwise the\n        # event loop locks up, because there won't be anything for the\n        # select call to process.\n        if sys.version_info >= (3, 8):\n            self.call_soon(self._loop_self_reading)\n\n        # Remember the application context.\n        self.app_context = app_context\n\n        # Register a custom user window message.\n        self.msg_id = user32.RegisterWindowMessageA(\"Python asyncio tick\")\n        # Add a message filter to listen for the asyncio tick message\n        # FIXME: Actually install the message filter.\n        # msg_filter = AsyncIOTickMessageFilter(self, self.msg_id)\n        # WinForms.Application.AddMessageFilter(msg_filter)\n\n        # Setup the Proactor.\n        # The code between the following markers should be exactly the same as\n        # the official CPython implementation, up to the start of the\n        # `while True:` part of run_forever() (see BaseEventLoop.run_forever()\n        # in Lib/ascynio/base_events.py)\n        # === START BaseEventLoop.run_forever() setup ===\n        self._check_closed()\n        if self.is_running():\n            raise RuntimeError('This event loop is already running')\n        if events._get_running_loop() is not None:\n            raise RuntimeError(\n                'Cannot run the event loop while another loop is running')\n        self._set_coroutine_origin_tracking(self._debug)\n        self._thread_id = threading.get_ident()\n        try:\n            self._old_agen_hooks = sys.get_asyncgen_hooks()\n            sys.set_asyncgen_hooks(\n                firstiter=self._asyncgen_firstiter_hook,\n                finalizer=self._asyncgen_finalizer_hook\n            )\n        except AttributeError:\n            # Python < 3.6 didn't have sys.get_asyncgen_hooks();\n            # No action required for those versions.\n            pass\n\n        events._set_running_loop(self)\n        # === END BaseEventLoop.run_forever() setup ===\n\n        # Rather than going into a `while True:` loop, we're going to use the\n        # Winforms event loop to queue a tick() message that will cause a\n        # single iteration of the asyncio event loop to be executed. Each time\n        # we do this, we queue *another* tick() message in 5ms time. In this\n        # way, we'll get a continuous stream of tick() calls, without blocking\n        # the Winforms event loop.\n\n        # Queue the first asyncio tick.\n        self.enqueue_tick()\n\n        # Start the Winforms event loop.\n        WinForms.Application.Run(self.app_context)\n\n    def enqueue_tick(self):\n        # Queue a call to tick in 5ms.\n        Task.Delay(5).ContinueWith(Action[Task](self.tick))\n\n    def tick(self, *args, **kwargs):\n        \"\"\"\n        Cause a single iteration of the event loop to run on the main GUI thread.\n        \"\"\"\n        # Post a userspace message that will trigger running an iteration\n        # of the asyncio event loop. This can't be done directly, because the\n        # tick() will be executing in a threadpool, and we need the asyncio\n        # handling to occur in the main GUI thread. However, by positing a\n        # message, it will be caught by the MessageFilter we installed on the\n        # Application thread.\n\n        # The message is sent with:\n        # * HWND 0xfff (all windows),\n        # * MSG self.msg_id (a message ID in the WM_USER range)\n        # * LPARAM and WPARAM empty (no extra details needed; just tick!)\n        user32.PostMessageA(0xffff, self.msg_id, None, None)\n\n        # FIXME: Once we have a working message filter, this invoke call\n        # can be removed.\n        # If the app context has a main form, invoke run_once_recurring()\n        # on the thread associated with that form.\n        if self.app_context.MainForm:\n            self.app_context.MainForm.Invoke(Action(self.run_once_recurring))\n\n    def run_once_recurring(self):\n        \"\"\"\n        Run one iteration of the event loop, and enqueue the next iteration\n        (if we're not stopping).\n\n        This largely duplicates the \"finally\" behavior of the default Proactor\n        run_forever implementation.\n        \"\"\"\n        # Perform one tick of the event loop.\n        self._run_once()\n\n        if self._stopping:\n            # If we're stopping, we can do the \"finally\" handling from\n            # the BaseEventLoop run_forever().\n            # === START BaseEventLoop.run_forever() finally handling ===\n            self._stopping = False\n            self._thread_id = None\n            events._set_running_loop(None)\n            self._set_coroutine_origin_tracking(False)\n            try:\n                sys.set_asyncgen_hooks(*self._old_agen_hooks)\n            except AttributeError:\n                # Python < 3.6 didn't have set_asyncgen_hooks.\n                # No action required for those versions.\n                pass\n            # === END BaseEventLoop.run_forever() finally handling ===\n        else:\n            # Otherwise, live to tick another day. Enqueue the next tick,\n            # and make sure there will be *something* to be processed.\n            # If you don't ensure there is at least one message on the\n            # queue, the select() call will block, locking the app.\n            self.enqueue_tick()\n            self.call_soon(self._loop_self_reading)\n\n\n# Python 3.7 changed the name of an internal wrapper function.\n# Install an alias for the old name at the new name.\nif sys.version_info < (3, 7):\n    WinformsProactorEventLoop._set_coroutine_origin_tracking = WinformsProactorEventLoop._set_coroutine_wrapper\n", "path": "src/winforms/toga_winforms/libs/proactor.py"}], "after_files": [{"content": "import asyncio\nimport sys\nimport threading\nfrom asyncio import events\n\nfrom .winforms import Action, Task, WinForms, user32\n\n\nclass AsyncIOTickMessageFilter(WinForms.IMessageFilter):\n    \"\"\"\n    A Winforms message filter that will catch the request to tick the Asyncio\n    event loop.\n    \"\"\"\n    __namespace__ = 'System.Windows.Forms'\n\n    def __init__(self, loop, msg_id):\n        self.loop = loop\n        self.msg_id = msg_id\n\n    def PreFilterMessage(self, message):\n        print('ping', message)\n        if message.Msg == self.msg_id:\n            print(\"asyncio tick message!!\")\n            self.loop.run_once_recurring()\n            return True\n        # print(\"Filter message\", message)\n        return False\n\n\nclass WinformsProactorEventLoop(asyncio.ProactorEventLoop):\n    def run_forever(self, app_context):\n        \"\"\"Set up the asyncio event loop, integrate it with the Winforms\n        event loop, and start the application.\n\n        This largely duplicates the setup behavior of the default Proactor\n        run_forever implementation.\n\n        :param app_context: The WinForms.ApplicationContext instance\n            controlling the lifecycle of the app.\n        \"\"\"\n        # Python 3.8 added an implementation of run_forever() in\n        # ProactorEventLoop. The only part that actually matters is the\n        # refactoring that moved the initial call to stage _loop_self_reading;\n        # it now needs to be created as part of run_forever; otherwise the\n        # event loop locks up, because there won't be anything for the\n        # select call to process.\n        if sys.version_info >= (3, 8):\n            self.call_soon(self._loop_self_reading)\n\n        # Remember the application context.\n        self.app_context = app_context\n\n        # Register a custom user window message.\n        self.msg_id = user32.RegisterWindowMessageA(\"Python asyncio tick\")\n        # Add a message filter to listen for the asyncio tick message\n        # FIXME: Actually install the message filter.\n        # msg_filter = AsyncIOTickMessageFilter(self, self.msg_id)\n        # WinForms.Application.AddMessageFilter(msg_filter)\n\n        # Setup the Proactor.\n        # The code between the following markers should be exactly the same as\n        # the official CPython implementation, up to the start of the\n        # `while True:` part of run_forever() (see BaseEventLoop.run_forever()\n        # in Lib/ascynio/base_events.py)\n        # === START BaseEventLoop.run_forever() setup ===\n        self._check_closed()\n        if self.is_running():\n            raise RuntimeError('This event loop is already running')\n        if events._get_running_loop() is not None:\n            raise RuntimeError(\n                'Cannot run the event loop while another loop is running')\n        self._set_coroutine_origin_tracking(self._debug)\n        self._thread_id = threading.get_ident()\n        try:\n            self._old_agen_hooks = sys.get_asyncgen_hooks()\n            sys.set_asyncgen_hooks(\n                firstiter=self._asyncgen_firstiter_hook,\n                finalizer=self._asyncgen_finalizer_hook\n            )\n        except AttributeError:\n            # Python < 3.6 didn't have sys.get_asyncgen_hooks();\n            # No action required for those versions.\n            pass\n\n        events._set_running_loop(self)\n        # === END BaseEventLoop.run_forever() setup ===\n\n        # Rather than going into a `while True:` loop, we're going to use the\n        # Winforms event loop to queue a tick() message that will cause a\n        # single iteration of the asyncio event loop to be executed. Each time\n        # we do this, we queue *another* tick() message in 5ms time. In this\n        # way, we'll get a continuous stream of tick() calls, without blocking\n        # the Winforms event loop.\n\n        # Queue the first asyncio tick.\n        self.enqueue_tick()\n\n        # Start the Winforms event loop.\n        WinForms.Application.Run(self.app_context)\n\n    def enqueue_tick(self):\n        # Queue a call to tick in 5ms.\n        self.task = Action[Task](self.tick)\n        Task.Delay(5).ContinueWith(self.task)\n\n    def tick(self, *args, **kwargs):\n        \"\"\"\n        Cause a single iteration of the event loop to run on the main GUI thread.\n        \"\"\"\n        # Post a userspace message that will trigger running an iteration\n        # of the asyncio event loop. This can't be done directly, because the\n        # tick() will be executing in a threadpool, and we need the asyncio\n        # handling to occur in the main GUI thread. However, by positing a\n        # message, it will be caught by the MessageFilter we installed on the\n        # Application thread.\n\n        if self.task:\n            self.task.Dispose()\n            del self.task\n        # The message is sent with:\n        # * HWND 0xfff (all windows),\n        # * MSG self.msg_id (a message ID in the WM_USER range)\n        # * LPARAM and WPARAM empty (no extra details needed; just tick!)\n        user32.PostMessageA(0xffff, self.msg_id, None, None)\n\n        # FIXME: Once we have a working message filter, this invoke call\n        # can be removed.\n        # If the app context has a main form, invoke run_once_recurring()\n        # on the thread associated with that form.\n        if self.app_context.MainForm:\n            action = Action(self.run_once_recurring)\n            self.app_context.MainForm.Invoke(action)\n            action.Dispose()\n            del action\n\n    def run_once_recurring(self):\n        \"\"\"\n        Run one iteration of the event loop, and enqueue the next iteration\n        (if we're not stopping).\n\n        This largely duplicates the \"finally\" behavior of the default Proactor\n        run_forever implementation.\n        \"\"\"\n        # Perform one tick of the event loop.\n        self._run_once()\n\n        if self._stopping:\n            # If we're stopping, we can do the \"finally\" handling from\n            # the BaseEventLoop run_forever().\n            # === START BaseEventLoop.run_forever() finally handling ===\n            self._stopping = False\n            self._thread_id = None\n            events._set_running_loop(None)\n            self._set_coroutine_origin_tracking(False)\n            try:\n                sys.set_asyncgen_hooks(*self._old_agen_hooks)\n            except AttributeError:\n                # Python < 3.6 didn't have set_asyncgen_hooks.\n                # No action required for those versions.\n                pass\n            # === END BaseEventLoop.run_forever() finally handling ===\n        else:\n            # Otherwise, live to tick another day. Enqueue the next tick,\n            # and make sure there will be *something* to be processed.\n            # If you don't ensure there is at least one message on the\n            # queue, the select() call will block, locking the app.\n            self.enqueue_tick()\n            self.call_soon(self._loop_self_reading)\n\n\n# Python 3.7 changed the name of an internal wrapper function.\n# Install an alias for the old name at the new name.\nif sys.version_info < (3, 7):\n    WinformsProactorEventLoop._set_coroutine_origin_tracking = WinformsProactorEventLoop._set_coroutine_wrapper\n", "path": "src/winforms/toga_winforms/libs/proactor.py"}]}