Update Async logic

src/modules/EventsSystem/events_system.py

@@ -13,51 +13,78 @@ class EventsSystem:
         # TODO: default events
         self.log = get_logger("EventsSystem")
         self.loop = asyncio.get_event_loop()
+        self.as_tasks = []
         self.__events = {
             "server_started": [],
-            "_plugins_start": [],
+            "auth_sent_key": [],  # Only sync
-            "auth_sent_key": [],
+            "auth_ok": [],  # Only sync
-            "auth_ok": [],
             "chat_receive": [],
-            "_plugins_unload": [],
             "server_stopped": [],
         }
+        self.__async_events = {
+            "server_started": [],
+            "_plugins_start": [],
+            "_plugins_unload": [],
+            "chat_receive": [],
+            "server_stopped": []
+        }
 
     def builtins_hook(self):
         self.log.debug("used builtins_hook")
         builtins.ev = self
 
-    def register_event(self, event_name, event_func):
+    def register_event(self, event_name, event_func, async_event=False):
         self.log.debug(f"register_event({event_name}, {event_func}):")
         if not callable(event_func):
             # TODO: i18n
             self.log.error(f"Cannot add event '{event_name}'. "
                            f"Use `KuiToi.add_event({event_name}', function)` instead. Skipping it...")
             return
-        if event_name not in self.__events:
+        if async_event or inspect.iscoroutinefunction(event_func):
-            self.__events.update({str(event_name): [event_func]})
+            if event_name not in self.__async_events:
+                self.__async_events.update({str(event_name): [event_func]})
+            else:
+                self.__async_events[event_name].append(event_func)
         else:
-            self.__events[event_name].append(event_func)
+            if event_name not in self.__events:
+                self.__events.update({str(event_name): [event_func]})
+            else:
+                self.__events[event_name].append(event_func)
 
-    def call_event(self, event_name, *args, **kwargs):
+    async def call_async_event(self, event_name, *args, **kwargs):
-        self.log.debug(f"Using event '{event_name}'")
+        self.log.debug(f"Calling async event: '{event_name}'")
         funcs_data = []
-
+        if event_name in self.__async_events.keys():
-        if event_name in self.__events.keys():
+            for func in self.__async_events[event_name]:
-            for func in self.__events[event_name]:
                 try:
                     event_data = {"event_name": event_name, "args": args, "kwargs": kwargs}
-                    if inspect.iscoroutinefunction(func):
+                    data = await func(event_data)
-                        d = self.loop.run_until_complete(func(event_data))
+                    funcs_data.append(data)
-                    else:
-                        d = func(event_data)
-                    funcs_data.append(d)
                 except Exception as e:
                     # TODO: i18n
                     self.log.error(f'Error while calling "{event_name}"; In function: "{func.__name__}"')
                     self.log.exception(e)
         else:
             # TODO: i18n
-            self.log.warning(f"Event {event_name} does not exist. Just skipping it...")
+            self.log.warning(f"Event {event_name} does not exist, maybe ev.call_event()?. Just skipping it...")
+
+        return funcs_data
+
+    def call_event(self, event_name, *args, **kwargs):
+        self.log.debug(f"Calling sync event: '{event_name}'")
+        funcs_data = []
+
+        if event_name in self.__events.keys():
+            for func in self.__events[event_name]:
+                try:
+                    event_data = {"event_name": event_name, "args": args, "kwargs": kwargs}
+                    funcs_data.append(func(event_data))
+                except Exception as e:
+                    # TODO: i18n
+                    self.log.error(f'Error while calling "{event_name}"; In function: "{func.__name__}"')
+                    self.log.exception(e)
+        else:
+            # TODO: i18n
+            self.log.warning(f"Event {event_name} does not exist, maybe ev.call_async_event()?. Just skipping it...")
 
         return funcs_data

src/modules/EventsSystem/events_systems-builtins.pyi

@@ -1,6 +1,11 @@
+from typing import Any
+
+
 class EventsSystem:
     @staticmethod
     def register_event(event_name, event_func): ...
     @staticmethod
-    def call_event(event_name, *data, **kwargs): ...
+    async def call_async_event(event_name, *args, **kwargs) -> list[Any]: ...
-class ev(EventsSystem): ...
+    @staticmethod
+    def call_event(event_name, *data, **kwargs) -> list[Any]: ...
+class ev(EventsSystem): ...