__

Author: NeloBlivion

discord/ui/core.py

@@ -72,30 +72,30 @@ def __init__(
             self.add_item(item)
 
         loop = asyncio.get_running_loop()
-        self.__cancel_callback: Callable[[View], None] | None = None
-        self.__timeout_expiry: float | None = None
-        self.__timeout_task: asyncio.Task[None] | None = None
-        self.__stopped: asyncio.Future[bool] = loop.create_future()
+        self._cancel_callback: Callable[[View], None] | None = None
+        self._timeout_expiry: float | None = None
+        self._timeout_task: asyncio.Task[None] | None = None
+        self._stopped: asyncio.Future[bool] = loop.create_future()
 
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__} timeout={self.timeout} children={len(self.children)}>"
 
-    async def __timeout_task_impl(self) -> None:
+    async def _timeout_task_impl(self) -> None:
         while True:
             # Guard just in case someone changes the value of the timeout at runtime
             if self.timeout is None:
                 return
 
-            if self.__timeout_expiry is None:
+            if self._timeout_expiry is None:
                 return self._dispatch_timeout()
 
             # Check if we've elapsed our currently set timeout
             now = time.monotonic()
-            if now >= self.__timeout_expiry:
+            if now >= self._timeout_expiry:
                 return self._dispatch_timeout()
 
             # Wait N seconds to see if timeout data has been refreshed
-            await asyncio.sleep(self.__timeout_expiry - now)
+            await asyncio.sleep(self._timeout_expiry - now)
 
     @property
     def _expires_at(self) -> float | None:

discord/ui/modal.py

@@ -92,14 +92,14 @@ def __repr__(self) -> str:
         return f"<{self.__class__.__name__} {attrs}>"
 
     def _start_listening_from_store(self, store: ModalStore) -> None:
-        self.__cancel_callback = partial(store.remove_modal)
+        self._cancel_callback = partial(store.remove_modal)
         if self.timeout:
             loop = asyncio.get_running_loop()
-            if self.__timeout_task is not None:
-                self.__timeout_task.cancel()
+            if self._timeout_task is not None:
+                self._timeout_task.cancel()
 
-            self.__timeout_expiry = time.monotonic() + self.timeout
-            self.__timeout_task = loop.create_task(self.__timeout_task_impl())
+            self._timeout_expiry = time.monotonic() + self.timeout
+            self._timeout_task = loop.create_task(self._timeout_task_impl())
 
     def _dispatch_timeout(self):
         if self._stopped.done():
@@ -208,10 +208,10 @@ def stop(self) -> None:
         """Stops listening to interaction events from the modal."""
         if not self._stopped.done():
             self._stopped.set_result(True)
-        self.__timeout_expiry = None
-        if self.__timeout_task is not None:
-            self.__timeout_task.cancel()
-            self.__timeout_task = None
+        self._timeout_expiry = None
+        if self._timeout_task is not None:
+            self._timeout_task.cancel()
+            self._timeout_task = None
 
     async def wait(self) -> bool:
         """Waits for the modal to be submitted."""

discord/ui/view.py

@@ -360,7 +360,7 @@ def is_components_v2(self) -> bool:
     async def _scheduled_task(self, item: Item[V], interaction: Interaction):
         try:
             if self.timeout:
-                self.__timeout_expiry = time.monotonic() + self.timeout
+                self._timeout_expiry = time.monotonic() + self.timeout
 
             allow = await self.interaction_check(interaction)
             if not allow:
@@ -371,26 +371,26 @@ async def _scheduled_task(self, item: Item[V], interaction: Interaction):
             return await self.on_error(e, item, interaction)
 
     def _start_listening_from_store(self, store: ViewStore) -> None:
-        self.__cancel_callback = partial(store.remove_view)
+        self._cancel_callback = partial(store.remove_view)
         if self.timeout:
             loop = asyncio.get_running_loop()
-            if self.__timeout_task is not None:
-                self.__timeout_task.cancel()
+            if self._timeout_task is not None:
+                self._timeout_task.cancel()
 
-            self.__timeout_expiry = time.monotonic() + self.timeout
-            self.__timeout_task = loop.create_task(self.__timeout_task_impl())
+            self._timeout_expiry = time.monotonic() + self.timeout
+            self._timeout_task = loop.create_task(self._timeout_task_impl())
 
     def _dispatch_timeout(self):
-        if self.__stopped.done():
+        if self._stopped.done():
             return
 
-        self.__stopped.set_result(True)
+        self._stopped.set_result(True)
         asyncio.create_task(
             self.on_timeout(), name=f"discord-ui-view-timeout-{self.id}"
         )
 
     def _dispatch_item(self, item: Item[V], interaction: Interaction):
-        if self.__stopped.done():
+        if self._stopped.done():
             return
 
         if interaction.message:
@@ -403,14 +403,14 @@ def _dispatch_item(self, item: Item[V], interaction: Interaction):
 
     def is_finished(self) -> bool:
         """Whether the view has finished interacting."""
-        return self.__stopped.done()
+        return self._stopped.done()
 
     def is_dispatchable(self) -> bool:
         return any(item.is_dispatchable() for item in self.children)
 
     def is_dispatching(self) -> bool:
         """Whether the view has been added for dispatching purposes."""
-        return self.__cancel_callback is not None
+        return self._cancel_callback is not None
 
     def is_persistent(self) -> bool:
         """Whether the view is set up as persistent.
@@ -427,17 +427,17 @@ def stop(self) -> None:
 
         This operation cannot be undone.
         """
-        if not self.__stopped.done():
-            self.__stopped.set_result(False)
+        if not self._stopped.done():
+            self._stopped.set_result(False)
 
-        self.__timeout_expiry = None
-        if self.__timeout_task is not None:
-            self.__timeout_task.cancel()
-            self.__timeout_task = None
+        self._timeout_expiry = None
+        if self._timeout_task is not None:
+            self._timeout_task.cancel()
+            self._timeout_task = None
 
-        if self.__cancel_callback:
-            self.__cancel_callback(self)
-            self.__cancel_callback = None
+        if self._cancel_callback:
+            self._cancel_callback(self)
+            self._cancel_callback = None
 
     async def wait(self) -> bool:
         """Waits until the view has finished interacting.
@@ -451,7 +451,7 @@ async def wait(self) -> bool:
             If ``True``, then the view timed out. If ``False`` then
             the view finished normally.
         """
-        return await self.__stopped
+        return await self._stopped
 
     def disable_all_items(self, *, exclusions: list[Item[V]] | None = None) -> Self:
         """