Add sayncio_patch.py.md

sayncio_patch.py.md

@@ -0,0 +1,66 @@
+# AsyncPatch
+
+# A mixin written by me to use to enable async on all your non async classes! It's not only a patch to use it but actually really executes the code in the event loop!
+
+## How to use
+```python
+
+# (C) retoor 2024-12-01
+
+import os 
+import AsyncioPatch from asyncio_patch.py
+
+# Non async traditional class.
+class Reader:
+
+    def readline(self):
+        return os.stdin.readline()
+
+# Extend the class with the mixin.
+class AsyncReader(Reader, AsyncioPatch):
+    pass
+
+# Use it for blocking code.
+async def main():
+    reader = AsyncReader()
+    
+    # method 1
+    print(await reader.areadline())
+    
+    # method 2
+    print(await reader.readline_async())
+
+asyncio.run(main())
+```
+
+## Source code
+```python
+import asyncio
+
+class AsyncioPatch:
+    def __getattr__(self, name):
+        if name.endswith("_async"):
+            name = name.split("_async")[0]
+        elif name.startswith("a"):
+            name = name[1:]
+        else:
+            return self.__dict__.get(name, None)
+        return self.patch_async(getattr(self, name))
+
+
+    def patch_async(self, method, *args, **kwargs):
+        async def patched_async(*args, **kwargs):
+            loop = asyncio.get_running_loop()
+            import functools 
+            patched_call = functools.partial(method, *args, **kwargs)
+            return await loop.run_in_executor(None, patched_call)
+        return patched_async 
+    
+    async def __aenter__(self):
+        fn = self.patch_async(self.__enter__)
+        return await fn()
+
+    async def __aexit__(self, *args, **kwargs):
+        fn = self.patch_async(self.__exit__,*args, **kwargs)
+        return await fn()
+```