[+] multiprocessing support

README.md

@@ -11,5 +11,5 @@ fmt = "<green>{elapsed} -- {time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{leve
 
 Добавление в проект:
 ```bash
-git submodule add ssh://git@git.anidev.ru:222/roden-soft/EventsSystem.git src/modules/EventsSystem
+git submodule add ssh://git@git.anidev.ru:222/AnidevSoft/EventsSystem-module.git src/modules/EventsSystem
 ```

builtins.event.pyi

@@ -0,0 +1,35 @@
+from typing import Any
+
+
+class event:
+    @staticmethod
+    def register(event_name, callback) -> None:
+        """
+        Registers a callback for a given event name.
+
+        :param event_name: Name of the event.
+        :param callback: Callable to be executed when the event occurs.
+        """
+        ...
+
+    @staticmethod
+    def unregister(event_name, callback) -> None:
+        """
+        Unregisters a callback for a given event name.
+
+        :param event_name: Name of the event.
+        :param callback: Callable to be unregistered.
+        """
+        ...
+
+    @staticmethod
+    def call(event_name, *data, **kwargs) -> list[Any]:
+        """
+        Call all callbacks for a given event name.
+
+        :param event_name: Name of the event.
+        :param args: Data to be passed to callbacks.
+        :param kwargs: Additional data to be passed to callbacks.
+        :return: List of data returned by callbacks.
+        """
+        ...

events.py

@@ -1,39 +1,69 @@
 import builtins
+import multiprocessing
+from collections import defaultdict
 
 from loguru import logger
 
 log = logger.bind(module="EventsSystem", prefix="init")
-lor_reg = log.bind(prefix="register")
-lor_call = log.bind(prefix="call")
+log_reg = log.bind(prefix="register")
+log_unreg = log.bind(prefix="unregister")
+log_call = log.bind(prefix="call")
 
 class EventsSystem:
     def __init__(self):
-        self.__events = {}
+        if multiprocessing.current_process().name != "MainProcess":
+            return
+        self.__events = defaultdict(list)
         log.debug("Injected to builtins")
         builtins.event = self
         log.debug("EventsSystem ready")
 
     def register(self, event_name, callback):
-        lor_reg.debug(f"{event_name!r}; {callback.__name__}({callback})")
+        """
+        Registers a callback for a given event name.
+
+        :param event_name: Name of the event.
+        :param callback: Callable to be executed when the event occurs.
+        """
+        log_reg.debug(f"{event_name!r}; {callback.__name__}({callback})")
         if not callable(callback):
-            return lor_reg.error(f"Bad event '{event_name}' - cannot registered")
-        if event_name not in self.__events:
-            self.__events.update({str(event_name): [callback]})
+            return log_reg.error(f"Bad event '{event_name}' - cannot registered")
+        self.__events[event_name].append(callback)
+
+    def unregister(self, event_name, callback):
+        """
+        Unregisters a callback for a given event name.
+
+        :param event_name: Name of the event.
+        :param callback: Callable to be unregistered.
+        """
+        log_unreg.debug(f"{event_name!r}; {callback.__name__}({callback})")
+        if event_name in self.__events.keys():
+            self.__events[event_name].remove(callback)
         else:
-            self.__events[event_name].append(callback)
+            log_unreg.error(f"Event '{event_name}' not found.")
 
     def call(self, event_name, *args, **kwargs):
-        funcs_data = []
+        """
+        Call all callbacks for a given event name.
+
+        :param event_name: Name of the event.
+        :param args: Data to be passed to callbacks.
+        :param kwargs: Additional data to be passed to callbacks.
+        :return: List of data returned by callbacks.
+        """
+        kwargs['event_name'] = event_name
+        callbacks_data = []
         if event_name in self.__events.keys():
             for callback in self.__events[event_name]:
-                lor_call.debug(f"{event_name!r}; execute: '{callback.__name__}'; data: {args=}; {kwargs=}")
+                log_call.log("EVCALL", f"{event_name!r}; execute: '{callback.__name__}'; data: {args=}; {kwargs=}")
                 try:
-                    event_data = {"event_name": event_name, "args": args, "kwargs": kwargs}
-                    funcs_data.append(callback(event_data))
+                    event_data = callback(*args, **kwargs)
+                    callbacks_data.append(event_data)
                 except Exception as e:
-                    lor_call.error(f"Error in {callback.__name__}. See debug.log")
-                    lor_call.exception(e)
+                    log_call.error(f"Error in {callback.__name__}. See debug.log")
+                    log_call.exception(e)
         else:
-            lor_call.error(f"Event '{event_name}' not found.")
+            log_call.error(f"Event '{event_name}' not found.")
 
-        return funcs_data
+        return callbacks_data