3.0.2

Author: davidhozic

docs/source/changelog.rst

@@ -37,6 +37,12 @@ Glossary
 Releases
 ---------------------
 
+v3.0.2
+====================
+- Fixed AutoGUILD not sending messages (events emitted prematurely).
+- Fixed TextMESSAGE and VoiceMESSAGE not being removed after n sends when using AutoCHANNEL.
+- Added missing :py:attr:`daf.guild.AutoGUILD.removed_messages` property.
+
 v3.0.1
 ====================
 - Downgraded Selenium version from 4.13 to 4.12 since 4.13 does not support headless, which

src/daf/__init__.py

@@ -17,4 +17,4 @@
 from .remote import *
 
 
-VERSION = "3.0.1"
+VERSION = "3.0.2"

src/daf/client.py

@@ -428,14 +428,15 @@ async def initialize(self):
             raise exc
 
         self._event_ctrl.add_listener(EventID.account_update, self._on_update)
-        for server in self._servers:
-            if (await server.initialize(self, self._event_ctrl)) is not None:
-                await self._on_remove_server(server)
-
         self._event_ctrl.add_listener(EventID.server_removed, self._on_remove_server)
         self._event_ctrl.add_listener(EventID.server_added, self._on_add_server)
         self._event_ctrl.start()
         self._running = True
+        async with self._event_ctrl.critical():
+            for server in self._servers:
+                if (await server.initialize(self, self._event_ctrl)) is not None:
+                    await self._on_remove_server(server)
+
 
     def generate_log_context(self) -> Dict[str, Union[str, int]]:
         """

src/daf/core.py

@@ -500,12 +500,13 @@ async def shutdown() -> None:
 
     GLOBALS.accounts.clear()
     evt.remove_listener(EventID.g_account_expired, cleanup_account)
-    await evt.stop()
+
+    trace("Shutdown complete.", TraceLEVELS.NORMAL)
 
     if remote.GLOBALS.remote_client is not None:
         await remote.GLOBALS.remote_client._close()
 
-    trace("Shutdown complete.", TraceLEVELS.NORMAL)
+    await evt.stop()
 
 
 def _shutdown_clean(loop: asyncio.AbstractEventLoop) -> None:

src/daf/events.py

@@ -2,9 +2,10 @@
 Module used to support listening and emitting events.
 It also contains the event loop definitions.
 """
-from contextlib import suppress
+from contextlib import suppress, asynccontextmanager
 from enum import Enum, auto
 from typing import Any, List, Dict, Callable, TypeVar, Coroutine, Set, Union
+from sys import _getframe
 
 from .misc.doc import doc_category
 
@@ -47,6 +48,7 @@ def __init__(self) -> None:
         self.event_queue = asyncio.Queue()
         self.loop_task: asyncio.Task = None
         self.running = False
+        self._critical_lock = asyncio.Lock()
 
     def start(self):
         """
@@ -61,6 +63,16 @@ def start(self):
             if self is not GLOBAL.g_controller:
                 GLOBAL.non_global_controllers.add(self)
 
+    @asynccontextmanager
+    async def critical(self):
+        """
+        Asynchronous Context manager (``async with`` statement), that prevents
+        any events from being processed until this critical section is exited.
+        """
+        await self._critical_lock.acquire()
+        yield
+        self._critical_lock.release()
+
     def stop(self):
         "Stops event loop asynchronously"
         if self.running:
@@ -142,6 +154,13 @@ def emit(self, event: "EventID", *args, **kwargs) -> asyncio.Future:
         future = asyncio.Future()
         if not self.running:
             future.set_result(None)
+            caller_frame = _getframe(1)
+            caller_info = caller_frame.f_code
+            caller_text = f"{caller_info.co_name} ({caller_info.co_filename})"
+            warnings.warn(
+                f"{self} is not running, but {event} was emitted, which was ignored! Caller: {caller_text}",
+                stacklevel=2
+            )
             return future
 
         self.event_queue.put_nowait((event, args, kwargs, future))
@@ -174,21 +193,21 @@ async def event_loop(self):
 
         while self.running:
             event_id, args, kwargs, future = await queue.get()
+            async with self._critical_lock:
+                for listener in listeners.get(event_id, [])[:]:
+                    try:
+                        if listener.predicate is None or listener.predicate(*args, **kwargs):
+                            if isinstance(r:= listener(*args, **kwargs), Coroutine):
+                                await r
 
-            for listener in listeners.get(event_id, [])[:]:
-                try:
-                    if listener.predicate is None or listener.predicate(*args, **kwargs):
-                        if isinstance(r:= listener(*args, **kwargs), Coroutine):
-                            await r
+                    except Exception as exc:
+                        warnings.warn(f"({exc}) Could not call event handler {listener} for event {event_id}.")
+                        future.set_exception(exc)
+                        break
 
-                except Exception as exc:
-                    warnings.warn(f"({exc}) Could not call event handler {listener} for event {event_id}.")
-                    future.set_exception(exc)
-                    break
 
-
-            if not future.done():  # In case exception was set
-                future.set_result(None)
+                if not future.done():  # In case exception was set
+                    future.set_result(None)
 
         if self is not GLOBAL.g_controller:
             GLOBAL.non_global_controllers.remove(self)
@@ -364,6 +383,7 @@ async def server_update(server):
     :type server: daf.guild.GUILD | daf.guild.USER | daf.guild.AutoGUILD
     """
 
+@doc_category("Event reference")
 async def auto_guild_start_join(auto_guild):
     """
     Event that is emitted when the join for new server should start.

src/daf/guild/autoguild.py

@@ -101,13 +101,12 @@ def __init__(
         self.include_pattern = re.sub(r"\s*\|\s*", '|', include_pattern) if include_pattern else None
         self.exclude_pattern = re.sub(r"\s*\|\s*", '|', exclude_pattern) if exclude_pattern else None
         self._remove_after = remove_after
-        self._messages = messages
+        self._messages: List[BaseMESSAGE] = messages
         self.logging = logging
         self.auto_join = auto_join
         self.parent = None
         self.guild_query_iter = None
         self.guild_join_count = 0
-        self._messages: List[BaseMESSAGE] = []
         self.removal_buffer_length = removal_buffer_length
         self._removal_timer_handle: asyncio.Task = None
         self._guild_join_timer_handle: asyncio.Task = None
@@ -124,6 +123,11 @@ def __init__(
     def __repr__(self) -> str:
         return f"AutoGUILD(include_pattern='{self.include_pattern}', exclude_pattern='{self.exclude_pattern})'"
 
+    @property
+    def removed_messages(self) -> List[BaseMESSAGE]:
+        "Returns a list of messages that were removed from server (last ``removal_buffer_length`` messages)."
+        return self._removed_messages[:]
+
     @property
     def messages(self) -> List[Union[TextMESSAGE, VoiceMESSAGE]]:
         """
@@ -263,11 +267,6 @@ async def initialize(self, parent: Any, event_ctrl: EventController):
 
             self.guild_query_iter = self.auto_join._query_request()
 
-        message: BaseChannelMessage
-        for message in self._messages:
-            if (await message.initialize(self, event_ctrl, self._get_channels)) is not None:
-                await self._on_remove_message(self, message)
-
         if self._remove_after is not None:
             if isinstance(self._remove_after, timedelta):
                 self._remove_after = datetime.now().astimezone() + self._remove_after
@@ -323,6 +322,11 @@ async def initialize(self, parent: Any, event_ctrl: EventController):
         event_ctrl.add_listener(EventID.message_removed, self._on_remove_message, lambda server, m: server is self)
         event_ctrl.add_listener(EventID.server_update, self._on_update, lambda server, *args, **kwargs: server is self)
 
+        message: BaseChannelMessage
+        for message in self._messages:
+            if (await message.initialize(self, event_ctrl, self._get_channels)) is not None:
+                await self._on_remove_message(self, message)
+
     def _generate_guild_log_context(self, guild: discord.Guild):
         return {
                 "name": guild.name,
@@ -368,10 +372,6 @@ async def _advertise(self, _, message: BaseMESSAGE):
         """
         Advertises thru all the GUILDs.
         """
-        if message._check_state():
-            await self.remove_message(message)
-            return
-
         author_ctx = self.parent.generate_log_context()
         message_context = await message._send()
         if message_context and self.logging:

src/daf/guild/guilduser.py

@@ -276,8 +276,6 @@ async def initialize(self, parent: Any, event_ctrl: EventController, getter: Cal
             trace(f"Invalid ID {self.snowflake} - {self}", TraceLEVELS.ERROR, exception_cls=ValueError)
 
         self._apiobject = _apiobject
-        await self._init_messages()
-
         if self._remove_after is not None:
             if isinstance(self._remove_after, timedelta):
                 self._remove_after = datetime.now().astimezone() + self._remove_after
@@ -298,6 +296,8 @@ async def initialize(self, parent: Any, event_ctrl: EventController, getter: Cal
         event_ctrl.add_listener(EventID.message_added, self._on_add_message, lambda server, m: server is self)
         event_ctrl.add_listener(EventID.server_update, self._on_update, lambda server, *h, **k: server is self)
 
+        await self._init_messages()
+
     def generate_invite_log_context(self, member: discord.Member, invite_id: str) -> dict:
         raise NotImplementedError
 

src/daf/message/base.py

@@ -585,7 +585,7 @@ def remove_after(self) -> Union[int, datetime, None]:
         """
         # An integer was originally provided, the dict is remove_after by each channel
         if isinstance(self._remove_after_original, int):
-            return max(self._remove_after.values()) if self._remove_after else self._remove_after_original
+            return max(self._remove_after.values(), default=self._remove_after_original)
 
         return self._remove_after
 
@@ -611,6 +611,11 @@ def _update_state(self, succeeded_channels: List[ChannelType], err_channels: Lis
                     )
                     self.channels.remove(channel)
                     del self._remove_after[snowflake]
+                
+            if not self._remove_after:  # All channel counts expired
+                self._event_ctrl.emit(EventID.message_removed, self.parent, self)
+                # Prevent dual removal events, errored channels also don't need to be removed if the message is removed
+                return
 
         # Remove any channels that returned with code status 404 (They no longer exist)
         for data in err_channels: