izUdZddlmZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl m Z mZmZmZmZmZmZmZmZmZmZmZmZmZddlZddlmZddlmZddlm Z m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'dd l(m)Z)dd l*m+Z+m,Z,ddl-m.Z.ddl/m0Z0m1Z1m2Z2m3Z3erddl4m5Z5m6Z6ddl7Zddl8m9Z9ddl:m;Z;ddlZ>ddl?m@Z@mAZAmBZBmCZCmDZDmEZEddl"mFZFddl/mGZGmDZDmHZHmIZImJZJddlKmLZLddlMmNZNeeeOeOfZPeEeAe9gePfZQeePeQeAfZRGddeLdZSGddeNeSZTdZUed ZVed!d"#ZWe jXeYZZd9d*Z[d:d.Z\Gd/d0Z]e]Z^d1e_d2<Gd3d4e#dZ`Gd5d6e`ejaZbGd7d8e`ejcZddS);a: The MIT License (MIT) Copyright (c) 2015-present Rapptz Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ) annotationsN)AnyCallableMappingListDict TYPE_CHECKINGOptionalSequenceTypeVarTypeUnionIterable Collectionoverload) app_commands)_retrieve_guild_ids)MISSING _is_submodule) GroupMixin) StringView)Context)errors) HelpCommandDefaultHelpCommand)Cog)hybrid_command hybrid_group HybridCommand HybridGroup)SelfUnpack)Message) Interaction)User Snowflake)_BotBotT UserCheckCoroFuncContextTMaybeAwaitableFunc)Command)CommandCallbackr,P_HybridCommandDecoratorKwargs_HybridGroupDecoratorKwargs)_ClientOptions)_AutoShardedClientOptionsc8eZdZUded<ded<ded<ded<dS) _BotOptionsz Optional[int]owner_idzOptional[Collection[int]] owner_idsboolstrip_after_prefixcase_insensitiveN)__name__ __module__ __qualname____annotations__Y/usr/local/lib/hermes-agent/venv/lib/python3.11/site-packages/discord/ext/commands/bot.pyr6r6[sB,,,,    rAr6F)totalceZdZdS)_AutoShardedBotOptionsN)r<r=r>r@rArBrErEasrArE)when_mentionedwhen_mentioned_orBotAutoShardedBotTCFTr+)boundbotr(msgr$return List[str]cBd|jjdd|jjdgS)aA callable that implements a command prefix equivalent to being mentioned. These are meant to be passed into the :attr:`.Bot.command_prefix` attribute. .. versionchanged:: 2.0 ``bot`` and ``msg`` parameters are now positional-only. z<@z> z<@!)userid)rMrNs rBrFrFqs. ! "7 "7"7"7 88rAprefixesstr$Callable[[_Bot, Message], List[str]]cfd}|S)aA callable that implements when mentioned or other prefixes provided. These are meant to be passed into the :attr:`.Bot.command_prefix` attribute. Example -------- .. code-block:: python3 bot = commands.Bot(command_prefix=commands.when_mentioned_or('!')) .. note:: This callable returns another callable, so if this is done inside a custom callable, you must call the returned callable, for example: .. code-block:: python3 async def get_prefix(bot, message): extras = await prefixes_for(message.guild) # returns a list return commands.when_mentioned_or(*extras)(bot, message) See Also ---------- :func:`.when_mentioned` cLt}t|||z}|SN)listrF)rMrNrrTs rBinnerz when_mentioned_or..inners' NN 3 $ $q (rAr@)rTr\s` rBrGrG~s#< LrAceZdZdZdS) _DefaultReprcdS)Nzr@selfs rB__repr__z_DefaultRepr.__repr__s''rAN)r<r=r>rbr@rArBr^r^s#(((((rAr^r_defaultcJeZdZeejdeeddfdZdfd Zdfd Z e j e j jdfd Ze j ejdfd Ze j ejdfd# Zed$fdd*Zed$fdd-Zdd2Zdd5Zd6d7dd:Zd6d7dd;Zdd=Zd6d7dd?ZddBZddDZddEZefddGZefddHZefddJZd6eedKddSZ ddUZ!eedVddWZ"e#ddYZ$ddZZ%dd^Z&ddaZ'ddcZ(dddddeZ)dddddfZ*dddddgZ+e#ddiZ,e#ddjZ-e-j.ddlZ-e#ddnZ/ddrZ0e1ddvZ2e1ddzZ2ed{dd|Z2dd}Z3dd~Z4ddZ5xZ6S)BotBaseN help_commandtree_cls descriptionallowed_contextsallowed_installscommand_prefixPrefixType[BotT]rgOptional[HelpCommand]rh#Type[app_commands.CommandTree[Any]]ri Optional[str]rjapp_commands.AppCommandContextrk app_commands.AppInstallationTypeintentsdiscord.IntentsoptionsUnpack[_BotOptions]rONonec >tjd d|i|||_i|_|||_|t ur ||j_|t ur ||j_i|_i|_ g|_ g|_ d|_ d|_ d|_|rtj|nd|_|d|_|dt)|_|dd|_|jr|jrt/d|jrEt1|jt2jjs!t/d|jjj|t<urt?|_ dS||_ dS) Nrsr7r8r:Fz$Both owner_id and owner_ids are set.z#owner_ids must be a collection not r@)!super__init__rl extra_events_BotBase__treerrjrk_BotBase__cogs_BotBase__extensions_checks _check_once_before_invoke _after_invoke _help_commandinspectcleandocrigetr7setr8r: TypeError isinstance collectionsabcr __class__r<rcrrg) rarlrgrhrirjrkrsrurs rBr{zBotBase.__init__s 444G4440>796>htnn 7 * *+;DK ( 7 * *+;DK (&( 9;(* ,.261548AL T 0 = = =RT'.{{:'>'> 4;KK SUU4S4S(/ 4H%(P(P = DT^ DBCC C > g*T^[_=W"X"X ge$.BZBceeff f 8 # # 2 4 4D    ,D   rAcKtd{V|j}|jjst |r |t upSt|tp>t|tj j ott|dk}|rtddSdSdS)NrzPPrivileged message content intent is missing, commands may not work as expected.)rz_async_setup_hookrlrsmessage_contentcallablerFrrUrrrlenrZ_logwarning)raprefixtrigger_warningrs rBrzBotBase._async_setup_hooksgg'')))))))))$ |+ q&!!BfN&B]fc**]v{'?@@[SfEVEVZ[E[   q oppppp q q  q qrA event_namerUargsrkwargsctj|g|Ri|d|z}|j|gD]}|j||g|Ri|dS)Non_)rzdispatchr|r_schedule_event)rarrreveventrs rBrzBotBase.dispatchs5d555f555 Z &**2r22 = =E D  X;V;V;V.WWWW rAT#Union[str, app_commands.locale_str]with_app_commandr9%Unpack[_HybridCommandDecoratorKwargs]JCallable[[CommandCallback[Any, ContextT, P, T]], HybridCommand[Any, P, T]]c$dfd }|S)a`A shortcut decorator that invokes :func:`~discord.ext.commands.hybrid_command` and adds it to the internal command list via :meth:`add_command`. Returns -------- Callable[..., :class:`HybridCommand`] A decorator that converts the provided method into a Command, adds it to the bot, then returns it. func$CommandCallback[Any, ContextT, P, T]cdtd|}||SNparent)rr) setdefaultrrrresultrrrrars rB decoratorz)BotBase.hybrid_command..decorator2sX   h - - -b^GWbb[abbcghhF   V $ $ $MrArrr@rarrrrrs````` rBrzBotBase.hybrid_command"A            rA#Unpack[_HybridGroupDecoratorKwargs]HCallable[[CommandCallback[Any, ContextT, P, T]], HybridGroup[Any, P, T]]c$dfd }|S)aZA shortcut decorator that invokes :func:`~discord.ext.commands.hybrid_group` and adds it to the internal command list via :meth:`add_command`. Returns -------- Callable[..., :class:`HybridGroup`] A decorator that converts the provided method into a Group, adds it to the bot, then returns it. rrcdtd|}||Sr)rrrrs rBrz'BotBase.hybrid_group..decoratorJsX   h - - -`\dtEU``Y_``aeffF   V $ $ $MrArr@rs````` rBrzBotBase.hybrid_group:rrAcontext Context[BotT] exceptionerrors.CommandErrorcK|jddrdS|j}|r|rdS|j}|r|rdSt d||dS)a|coro| The default command error handler provided by the bot. By default this logs to the library logger, however it could be overridden to have a different implementation. This only fires if you do not specify any listeners for command error. .. versionchanged:: 2.0 ``context`` and ``exception`` parameters are now positional-only. Instead of writing to ``sys.stderr`` this now uses the library logger. on_command_errorNz Ignoring exception in command %s)exc_info)r|rrhas_error_handlerrrerror)rarrrrs rBrzBotBase.on_command_errorTs   !3T : :  F/  w0022  Fk  3((**  F 5w SSSSSrArrJc0|||S)aHA decorator that adds a global check to the bot. A global check is similar to a :func:`.check` that is applied on a per command basis except it is run before any command checks have been verified and applies to every command the bot has. .. note:: This function can either be a regular function or a coroutine. Similar to a command :func:`.check`\, this takes a single parameter of type :class:`.Context` and can only raise exceptions inherited from :exc:`.CommandError`. Example --------- .. code-block:: python3 @bot.check def check_commands(ctx): return ctx.command.qualified_name in allowed_commands .. versionchanged:: 2.0 ``func`` parameter is now positional-only.  add_checkrars rBcheckz BotBase.checkrs: t rAF call_onceUserCheck[ContextT]rcv|r|j|dS|j|dS)aAdds a global check to the bot. This is the non-decorator interface to :meth:`.check` and :meth:`.check_once`. .. versionchanged:: 2.0 ``func`` parameter is now positional-only. .. seealso:: The :func:`~discord.ext.commands.check` decorator Parameters ----------- func The function that was used as a global check. call_once: :class:`bool` If the function should only be called once per :meth:`.invoke` call. N)rappendr)rarrs rBrzBotBase.add_checksE*  &   # #D ) ) ) ) ) L   % % % % %rAct|r|jn|j} ||dS#t$rYdSwxYw)aRemoves a global check from the bot. This function is idempotent and will not raise an exception if the function is not in the global checks. .. versionchanged:: 2.0 ``func`` parameter is now positional-only. Parameters ----------- func The function to remove from the global checks. call_once: :class:`bool` If the function was added with ``call_once=True`` in the :meth:`.Bot.add_check` call or using :meth:`.check_once`. N)rrremove ValueError)rarrls rB remove_checkzBotBase.remove_checksR$!* ;D  t|  HHTNNNNN    DD s ) 77rKc4||d|S)aA decorator that adds a "call once" global check to the bot. Unlike regular global checks, this one is called only once per :meth:`.invoke` call. Regular global checks are called whenever a command is called or :meth:`.Command.can_run` is called. This type of check bypasses that and ensures that it's called only once, even inside the default help command. .. note:: When using this function the :class:`.Context` sent to a group subcommand may only parse the parent command and not the subcommands due to it being invoked once per :meth:`.Bot.invoke` call. .. note:: This function can either be a regular function or a coroutine. Similar to a command :func:`.check`\, this takes a single parameter of type :class:`.Context` and can only raise exceptions inherited from :exc:`.CommandError`. Example --------- .. code-block:: python3 @bot.check_once def whitelist(ctx): return ctx.message.author.id in my_whitelist .. versionchanged:: 2.0 ``func`` parameter is now positional-only. Trrrs rB check_oncezBotBase.check_onces N tt,,, rActxcK|r|jn|j}t|dkrdStjfd|Dd{VS)NrTc3.K|]}|VdSrYr@).0frs rB z"BotBase.can_run..s+,B,BQQsVV,B,B,B,B,B,BrA)rrrrutils async_all)rarrdatas ` rBcan_runzBotBase.can_runsl#,>t$, t99>>4],,,B,B,B,BT,B,B,BBBBBBBBBBrArRr&c(K|jr|j|jkS|jr|j|jvS|d{V}|jr&d|jjDx|_}|j|vS|jjx|_}|j|kS)a|coro| Checks if a :class:`~discord.User` or :class:`~discord.Member` is the owner of this bot. If an :attr:`owner_id` is not set, it is fetched automatically through the use of :meth:`~.Bot.application_info`. .. versionchanged:: 1.3 The function also checks if the application is team-owned if :attr:`owner_ids` is not set. .. versionchanged:: 2.0 ``user`` parameter is now positional-only. .. versionchanged:: 2.4 This function now respects the team member roles if the bot is team-owned. In order to be considered an owner, they must be either an admin or a developer. Parameters ----------- user: :class:`.abc.User` The user to check for. Returns -------- :class:`bool` Whether the user is the owner. Ncnh|]2}|jtjjtjjfv+|j3Sr@)rolerTeamMemberRoleadmin developerrS)rms rB z#BotBase.is_owner.. sB(((v'"8">@V@`!aaaDaaarA)r7rSr8application_infoteammembersowner)rarRappidsr7s rBis_ownerzBotBase.is_ownersD = +7dm+ + ^ +7dn, ,)-)>)>)@)@#@#@#@#@#@#@Cx +(( X-((( w#~%+.9<7 w(**rAcorocZtj|std||_|S)aA decorator that registers a coroutine as a pre-invoke hook. A pre-invoke hook is called directly before the command is called. This makes it a useful function to set up database connections or any type of set up required. This pre-invoke hook takes a sole parameter, a :class:`.Context`. .. note:: The :meth:`~.Bot.before_invoke` and :meth:`~.Bot.after_invoke` hooks are only called if all checks and argument parsing procedures pass without error. If any check or argument parsing procedures fail then the hooks are not called. .. versionchanged:: 2.0 ``coro`` parameter is now positional-only. Parameters ----------- coro: :ref:`coroutine ` The coroutine to register as the pre-invoke hook. Raises ------- TypeError The coroutine passed is not actually a coroutine. z(The pre-invoke hook must be a coroutine.)asyncioiscoroutinefunctionrrrars rB before_invokezBotBase.before_invoke*s4<*400 HFGG G" rAcZtj|std||_|S)a%A decorator that registers a coroutine as a post-invoke hook. A post-invoke hook is called directly after the command is called. This makes it a useful function to clean-up database connections or any type of clean up required. This post-invoke hook takes a sole parameter, a :class:`.Context`. .. note:: Similar to :meth:`~.Bot.before_invoke`\, this is not called unless checks and argument parsing procedures succeed. This hook is, however, **always** called regardless of the internal command callback raising an error (i.e. :exc:`.CommandInvokeError`\). This makes it ideal for clean-up scenarios. .. versionchanged:: 2.0 ``coro`` parameter is now positional-only. Parameters ----------- coro: :ref:`coroutine ` The coroutine to register as the post-invoke hook. Raises ------- TypeError The coroutine passed is not actually a coroutine. z)The post-invoke hook must be a coroutine.)rrrrrs rB after_invokezBotBase.after_invokeNs4>*400 IGHH H! rAr+c|tur|jn|}tj|st d||jvr"|j||dS|g|j|<dS)anThe non decorator alternative to :meth:`.listen`. .. versionchanged:: 2.0 ``func`` parameter is now positional-only. Parameters ----------- func: :ref:`coroutine ` The function to call. name: :class:`str` The name of the event to listen for. Defaults to ``func.__name__``. Example -------- .. code-block:: python3 async def on_ready(): pass async def my_message(message): pass bot.add_listener(on_ready) bot.add_listener(my_message, 'on_message') zListeners must be coroutinesN)rr<rrrr|rrarrs rB add_listenerzBotBase.add_listenerus~4!%t}}T*400 <:;; ; 4$ $ $  d # * *4 0 0 0 0 0'+fD d # # #rAc|tur|jn|}||jvr4 |j||dS#t$rYdSwxYwdS)aRemoves a listener from the pool of listeners. .. versionchanged:: 2.0 ``func`` parameter is now positional-only. Parameters ----------- func The function that was used as a listener to remove. name: :class:`str` The name of the event we want to remove. Defaults to ``func.__name__``. N)rr<r|rrr s rBremove_listenerzBotBase.remove_listenersv !%t}}T 4$ $ $ !$'..t44444     % $s ? A  A Callable[[CFT], CFT]cdfd }|S)aA decorator that registers another function as an external event listener. Basically this allows you to listen to multiple events from different places e.g. such as :func:`.on_ready` The functions being listened to must be a :ref:`coroutine `. Example -------- .. code-block:: python3 @bot.listen() async def on_message(message): print('one') # in some other file... @bot.listen('on_message') async def my_message(message): print('two') Would print one and two in an unspecified order. Raises ------- TypeError The function being listened to is not a coroutine. rrKrOc4||SrY)r )rrras rBrz!BotBase.listen..decorators   dD ) ) )KrArrKrOrKr@)rarrs`` rBlistenzBotBase.listens/<       rAoverriderguildsrrrrOptional[Snowflake]rSequence[Snowflake]cKt|tstd|j}|j|}|8|st jd|d||||d{V|j r#|j |j |||| ||||d{V}||j|<dS)ay|coro| Adds a "cog" to the bot. A cog is a class that has its own event listeners and commands. If the cog is a :class:`.app_commands.Group` then it is added to the bot's :class:`~discord.app_commands.CommandTree` as well. .. note:: Exceptions raised inside a :class:`.Cog`'s :meth:`~.Cog.cog_load` method will be propagated to the caller. .. versionchanged:: 2.0 :exc:`.ClientException` is raised when a cog with the same name is already loaded. .. versionchanged:: 2.0 ``cog`` parameter is now positional-only. .. versionchanged:: 2.0 This method is now a :term:`coroutine`. Parameters ----------- cog: :class:`.Cog` The cog to register to the bot. override: :class:`bool` If a previously loaded cog with the same name should be ejected instead of raising an error. .. versionadded:: 2.0 guild: Optional[:class:`~discord.abc.Snowflake`] If the cog is an application command group, then this would be the guild where the cog group would be added to. If not given then it becomes a global command instead. .. versionadded:: 2.0 guilds: List[:class:`~discord.abc.Snowflake`] If the cog is an application command group, then this would be the guilds where the cog group would be added to. If not given then it becomes a global command instead. Cannot be mixed with ``guild``. .. versionadded:: 2.0 Raises ------- TypeError The cog does not inherit from :class:`.Cog`. CommandError An error happened during loading. ClientException A cog with the same name is already loaded. zcogs must derive from CogNz Cog named z already loadedrrr) rrr __cog_name__r~rrClientExceptionr__cog_app_commands_group__r}r_inject)rarrrrcog_nameexistings rBadd_cogzBotBase.add_cogsJ#s## 9788 8#;??8,,   X-.V8.V.V.VWWW//(%/GG G G G G G G G  ) s K # #C$BX]bkq # r r rKKxuVKTTTTTTTT # HrA Optional[Cog]c6|j|S)aIGets the cog instance requested. If the cog is not found, ``None`` is returned instead. .. versionchanged:: 2.0 ``name`` parameter is now positional-only. Parameters ----------- name: :class:`str` The name of the cog you are requesting. This is equivalent to the name passed via keyword argument in class creation or the class name if unspecified. Returns -------- Optional[:class:`Cog`] The cog that was requested. If not found, returns ``None``. )r~r)rars rBget_cogzBotBase.get_cog-s*{t$$$rArcK|j|d}|dS|j}|r|j|urd|_t |||}|jrP||j|n3|D]0}|j|tj |1| ||d{V|S)a|coro| Removes a cog from the bot and returns it. All registered commands and event listeners that the cog has registered will be removed as well. If no cog is found then this method has no effect. .. versionchanged:: 2.0 ``name`` parameter is now positional-only. .. versionchanged:: 2.0 This method is now a :term:`coroutine`. Parameters ----------- name: :class:`str` The name of the cog to remove. guild: Optional[:class:`~discord.abc.Snowflake`] If the cog is an application command group, then this would be the guild where the cog group would be removed from. If not given then a global command is removed instead instead. .. versionadded:: 2.0 guilds: List[:class:`~discord.abc.Snowflake`] If the cog is an application command group, then this would be the guilds where the cog group would be removed from. If not given then a global command is removed instead instead. Cannot be mixed with ``guild``. .. versionadded:: 2.0 Returns ------- Optional[:class:`.Cog`] The cog that was removed. ``None`` if not found. Nr)r) r~poprrrrr}rrr_eject)rarrrrrgrrs rBrzBotBase.remove_cogDsbkoodD)) ; F)  $L,33#L 'UF;;  ) U  **40000 )UUHK..t7>(;S;S.TTTTjjj333333333 rAMapping[str, Cog]c4tj|jS)zLMapping[:class:`str`, :class:`Cog`]: A read-only mapping of cog name to cog.)typesMappingProxyTyper~r`s rBcogsz BotBase.cogss%dk222rAc0K|jD]5\}}t||jr||d{V6|jD]a}|jXt||jrCt|tr| | |j b|jD]_}g}t|D]6\}}|j*t||jr||7t#|D]}||=`|j|dSrY)r~copyitemsrr=r all_commandsvaluesmodulerrrecursively_remove_all_commandsrrr| enumeraterreversedr}_remove_with_module) rarcognamerr event_listrindexrs rB_remove_module_referencesz!BotBase._remove_module_referencess!K,,..4466 / /LGST3>22 /oog.........$))++2244 . .Cz%-cj*I*I%c:..:77999##CH---+002299;; & &JF )* 5 5 ) ) u#/M$HX4Y4Y/MM%(((!&)) & &u%% & ''-----rAlibtypes.ModuleTypekeycK t|d} ||d{Vn #t$rYnwxYw#t$rYnwxYw|j|dt j|d|j}tt j D]}t||r t j|= dS#|j|dt j|d|j}tt j D]}t||r t j|= wxYw)Nteardown) getattrrAttributeErrorrr'sysmodulesr<rZkeysr)rar<r>rrr3s rB_call_module_finalizerszBotBase._call_module_finalizerss ,3 ++D d4jj                 D    ! !#t , , , KOOC & & &r<erJs rB_load_from_module_speczBotBase._load_from_module_specsn--d33 C 8 K # #C ( ( ( ( 8 8 8 C (a00a 7 8 0C))EE 0 0 0 C *3// / 0 )%++       &)D c " " "  8 8 8 C 00>> > > > > > > >..sC88 8 8 8 8 8 8 8(a00a 7  8s<A A?#A::A?B,CC!! E+AE  Epackagec tj||S#t$rt j|wxYwrY)rKrL resolve_name ImportErrorrExtensionNotFound)rarrTs rB _resolve_namezBotBase._resolve_namesK 1>..tW== = 1 1 1*400 0 1s "A)rTcK|||}||jvrtj|tj|}|tj||||d{VdS)a|coro| Loads an extension. An extension is a python module that contains commands, cogs, or listeners. An extension must have a global function, ``setup`` defined as the entry point on what to do when the extension is loaded. This entry point must have a single argument, the ``bot``. .. versionchanged:: 2.0 This method is now a :term:`coroutine`. Parameters ------------ name: :class:`str` The extension name to load. It must be dot separated like regular Python imports if accessing a sub-module. e.g. ``foo.test`` if you want to import ``foo/test.py``. package: Optional[:class:`str`] The package name to resolve relative imports with. This is required when loading an extension using a relative path, e.g ``.foo.test``. Defaults to ``None``. .. versionadded:: 1.7 Raises -------- ExtensionNotFound The extension could not be imported. This is also raised if the name of the extension could not be resolved using the provided ``package`` parameter. ExtensionAlreadyLoaded The extension is already loaded. NoEntryPointError The extension does not have a setup function. ExtensionFailed The extension or its setup function had an execution error. N) rYrrExtensionAlreadyLoadedrKrL find_specrXrS)rarrTrGs rBload_extensionzBotBase.load_extensionsV!!$00 4$ $ $/55 5~''-- <*400 0))$55555555555rAcK|||}|j|}|tj|||jd{V|||d{VdS)a|coro| Unloads an extension. When the extension is unloaded, all commands, listeners, and cogs are removed from the bot and the module is un-imported. The extension can provide an optional global function, ``teardown``, to do miscellaneous clean-up if necessary. This function takes a single parameter, the ``bot``, similar to ``setup`` from :meth:`~.Bot.load_extension`. .. versionchanged:: 2.0 This method is now a :term:`coroutine`. Parameters ------------ name: :class:`str` The extension name to unload. It must be dot separated like regular Python imports if accessing a sub-module. e.g. ``foo.test`` if you want to import ``foo/test.py``. package: Optional[:class:`str`] The package name to resolve relative imports with. This is required when unloading an extension using a relative path, e.g ``.foo.test``. Defaults to ``None``. .. versionadded:: 1.7 Raises ------- ExtensionNotFound The name of the extension could not be resolved using the provided ``package`` parameter. ExtensionNotLoaded The extension was not loaded. N)rYrrrExtensionNotLoadedr;r<rF)rarrTr<s rBrzBotBase.unload_extensionsN!!$00##D)) ;+D11 1,,S\:::::::::**355555555555rAcBK|||}|j|tj|fdt jD} |j d{V| |d{V| |d{VdS#t$rF |d{V|j|<t j|wxYw)ay|coro| Atomically reloads an extension. This replaces the extension with the same extension, only refreshed. This is equivalent to a :meth:`unload_extension` followed by a :meth:`load_extension` except done in an atomic way. That is, if an operation fails mid-reload then the bot will roll-back to the prior working state. Parameters ------------ name: :class:`str` The extension name to reload. It must be dot separated like regular Python imports if accessing a sub-module. e.g. ``foo.test`` if you want to import ``foo/test.py``. package: Optional[:class:`str`] The package name to resolve relative imports with. This is required when reloading an extension using a relative path, e.g ``.foo.test``. Defaults to ``None``. .. versionadded:: 1.7 Raises ------- ExtensionNotLoaded The extension was not loaded. ExtensionNotFound The extension could not be imported. This is also raised if the name of the extension could not be resolved using the provided ``package`` parameter. NoEntryPointError The extension does not have a setup function. ExtensionFailed The extension setup function had an execution error. NcFi|]\}}tj|||Sr@)rr<)rrr3r<s rB z,BotBase.reload_extension..msA   fS\400 &   rA)rYrrrr_rCrDr0r;r<rFr]rrJupdate)rarrTrDr<s @rBreload_extensionzBotBase.reload_extensionAsiJ!!$00##D)) ;+D11 1    # 1 1 3 3    00>> > > > > > > >..sD99 9 9 9 9 9 9 9%%d++ + + + + + + + + +   ))D// ! ! ! ! ! ! !&)D d # K  w ' ' '  s5ACADMapping[str, types.ModuleType]c4tj|jS)zhMapping[:class:`str`, :class:`py:types.ModuleType`]: A read-only mapping of extension name to extension.)r+r,rr`s rB extensionszBotBase.extensionss%d&7888rAc|jSrY)rr`s rBrgzBotBase.help_commands !!rAvaluec2|ct|tstd|j|j|||_||dS|j#|j|d|_dSd|_dS)Nz.help_command must be a subclass of HelpCommand)rrrr_remove_from_bot _add_to_bot)raris rBrgzBotBase.help_commands  e[11 R PQQQ!-"33D999!&D    d # # # # #   +   / / 5 5 5!%D   !%D   rAapp_commands.CommandTree[Self]c|jS)z:class:`~discord.app_commands.CommandTree`: The command tree responsible for handling the application commands in this bot. .. versionadded:: 2.0 )r}r`s rBrz BotBase.trees {rAmessager$Union[List[str], str]chK|jx}}t|r'tj|||d{V}t |t s[ t|}nJ#t$r=t |tj j rtd|j j wxYw|S)a|coro| Retrieves the prefix the bot is listening to with the message as a context. .. versionchanged:: 2.0 ``message`` parameter is now positional-only. Parameters ----------- message: :class:`discord.Message` The message context to get the prefix of. Returns -------- Union[List[:class:`str`], :class:`str`] A list of prefixes or a single prefix that the bot is listening for. Nzecommand_prefix must be plain string, iterable of strings, or callable returning either of these, not )rlrrrmaybe_coroutinerrUrZrrrrrr<)rarorrets rB get_prefixzBotBase.get_prefixs*** F   M 55fdGLLLLLLLLC#s##  3ii   c;?#;<<O69m6LOO  s A((AB/originUnion[Message, Interaction] Context[Self]c KdSrYr@)rarus rB get_contextzBotBase.get_contexts rAclsType[ContextT]r,c KdSrYr@)rarurzs rBryzBotBase.get_contexts 3rA)rzcK|turt}t|tjr||d{VSt |j}|d|||}|jj |j j kr|S| |d{V}|}t|tr| |s|Sn |jt|r&tj|j |}n|Snv#t$$rit|t&st%d|jj|D]3}t|tst%d|jj4wxYw|jr||}||_||_|j||_|S)a|coro| Returns the invocation context from the message or interaction. This is a more low-level counter-part for :meth:`.process_commands` to allow users more fine grained control over the processing. The returned context is not guaranteed to be a valid invocation context, :attr:`.Context.valid` must be checked to make sure it is. If the context is not valid then it is not a valid candidate to be invoked under :meth:`~.Bot.invoke`. .. note:: In order for the custom context to be used inside an interaction-based context (such as :class:`HybridCommand`) then this method must be overridden to return that class. .. versionchanged:: 2.0 ``message`` parameter is now positional-only and renamed to ``origin``. Parameters ----------- origin: Union[:class:`discord.Message`, :class:`discord.Interaction`] The message or interaction to get the invocation context from. cls The factory class that will be used to create the context. By default, this is :class:`.Context`. Should a custom class be provided, it must be similar enough to :class:`.Context`\'s interface. Returns -------- :class:`.Context` The invocation context. The type of this can change via the ``cls`` parameter. N)rviewrMroz@get_prefix must return either a string or a list of string, not zXIterable command_prefix or list returned from get_prefix must contain only strings, not )rrrrr%from_interactionrcontentauthorrSrRrtrU skip_string startswithrrfindrrZrr<r:skip_wsget_word invoked_withrr1rr) rarurzr~rrinvoked_prefixriinvokers rBryzBotBase.get_contexts6Z '>>C fg1 2 2 6--f55555555 5&.))cDdFCCC = ty| + +Jv........ fc " " ##F++    >,,U6]];;%,]%7%78H&%Q%QNNJ#   !&$//#v[a[k[tvv $E%eS11'T9>9QTT "  "  LLNNN--//"# '++G44  sAD""A3FcK|j|d| ||dd{Vr!|j|d{Vnt jd |d|dS#tj$r,}|j||d{VYd}~dSd}~wwxYw|jr6t j d|jd}|d ||dSdS) a\|coro| Invokes the command given under the invocation context and handles all the internal event dispatch mechanisms. .. versionchanged:: 2.0 ``ctx`` parameter is now positional-only. Parameters ----------- ctx: :class:`.Context` The invocation context to invoke. NrTrz'The global check once functions failed.command_completionz Command "z" is not found command_error) rrrinvoker CheckFailure CommandErrordispatch_errorrCommandNotFound)rarexcs rBrzBotBase.invokeMse ; " MM)S ) ) ) 9cT::::::::Y+,,S1111111111 -.WXXX2  2C88888& ; ; ;k00c::::::::::::::: ;  5()US5E)U)U)UVVC MM/3 4 4 4 4 4 5 5sAB C!CCcK|jjrdS||d{V}||d{VdS)a|coro| This function processes the commands that have been registered to the bot and other groups. Without this coroutine, none of the commands will be triggered. By default, this coroutine is called inside the :func:`.on_message` event. If you choose to override the :func:`.on_message` event, then you should invoke this coroutine as well. This is built using other low level tools, and is equivalent to a call to :meth:`~.Bot.get_context` followed by a call to :meth:`~.Bot.invoke`. This also checks if the message's author is a bot and doesn't call :meth:`~.Bot.get_context` or :meth:`~.Bot.invoke` if so. .. versionchanged:: 2.0 ``message`` parameter is now positional-only. Parameters ----------- message: :class:`discord.Message` The message to process commands for. N)rrMryr)rarors rBprocess_commandszBotBase.process_commandsksi4 >   F$$W--------kk#rAc@K||d{VdSrY)r)raros rB on_messagezBotBase.on_messages2##G,,,,,,,,,,,rA)rlrmrgrnrhrorirprjrqrkrrrsrtrurvrOrw)rOrw)rrUrrrrrOrw)rrrOrw)rrUrOr) rrrr9rrrrrOr) rrrr9rrrrrOr)rrrrrOrw)rrJrOrJ)rrrr9rOrwr)rrrr9rOr9)rRr&rOr9)rrKrOrK)rrUrr+rOrw)rrUrOr) rrrr9rrrrrOrw)rrUrOr#)rrUrrrrrOr#)rOr))rrUrOrw)r<r=r>rUrOrw)rGrHr>rUrOrw)rrUrTrprOrU)rrUrTrprOrw)rOre)rOrn)rirnrOrw)rOrm)ror$rOrp)rurvrOrw)rurvrzr{rOr,)rurvrzr{rOr)rrrOrw)ror$rOrw)7r<r=r>rcr CommandTreerr{rrrrcopy_docClientrrrrrrrrrrrrrrr r rrr"r%rpropertyr-r;rFrSrYr]rrdrgrgsetterrrtrryrrr __classcell__)rs@rBreres /78D8P%);B=D+-+-+-+-+-+-+-+-^qqqqqq"====== ]GN011     21 " ]J233;;;;;43; ]J56676$5E0")"""""V%,&-T$T$T$T$T$T$l%%%%8&-&- CCCCCCJ333X3 ....6,,,,$))))41111 KO363636363636jMQ-6-6-6-6-6-6^MQAAAAAAF999X9 """X" & & & &&X))))V   X X& aaaaaaF5555<B--------rAreceZdZdZdS)rHa)Represents a Discord bot. This class is a subclass of :class:`discord.Client` and as a result anything that you can do with a :class:`discord.Client` you can do with this bot. This class also subclasses :class:`.GroupMixin` to provide the functionality to manage commands. Unlike :class:`discord.Client`, this class does not require manually setting a :class:`~discord.app_commands.CommandTree` and is automatically set upon instantiating the class. .. container:: operations .. describe:: async with x Asynchronously initialises the bot and automatically cleans up. .. versionadded:: 2.0 Attributes ----------- command_prefix The command prefix is what the message content must contain initially to have a command invoked. This prefix could either be a string to indicate what the prefix should be, or a callable that takes in the bot as its first parameter and :class:`discord.Message` as its second parameter and returns the prefix. This is to facilitate "dynamic" command prefixes. This callable can be either a regular function or a coroutine. An empty string as the prefix always matches, enabling prefix-less command invocation. While this may be useful in DMs it should be avoided in servers, as it's likely to cause performance issues and unintended command invocations. The command prefix could also be an iterable of strings indicating that multiple checks for the prefix should be used and the first one to match will be the invocation prefix. You can get this prefix via :attr:`.Context.prefix`. .. note:: When passing multiple prefixes be careful to not pass a prefix that matches a longer prefix occurring later in the sequence. For example, if the command prefix is ``('!', '!?')`` the ``'!?'`` prefix will never be matched to any message as the previous one matches messages starting with ``!?``. This is especially important when passing an empty string, it should always be last as no prefix after it will be matched. case_insensitive: :class:`bool` Whether the commands should be case insensitive. Defaults to ``False``. This attribute does not carry over to groups. You must set it to every group if you require group commands to be case insensitive as well. description: :class:`str` The content prefixed into the default help message. help_command: Optional[:class:`.HelpCommand`] The help command implementation to use. This can be dynamically set at runtime. To remove the help command pass ``None``. For more information on implementing a help command, see :ref:`ext_commands_help_command`. owner_id: Optional[:class:`int`] The user ID that owns the bot. If this is not set and is then queried via :meth:`.is_owner` then it is fetched automatically using :meth:`~.Bot.application_info`. owner_ids: Optional[Collection[:class:`int`]] The user IDs that owns the bot. This is similar to :attr:`owner_id`. If this is not set and the application is team based, then it is fetched automatically using :meth:`~.Bot.application_info`. For performance reasons it is recommended to use a :class:`set` for the collection. You cannot set both ``owner_id`` and ``owner_ids``. .. versionadded:: 1.3 strip_after_prefix: :class:`bool` Whether to strip whitespace characters after encountering the command prefix. This allows for ``! hello`` and ``!hello`` to both work if the ``command_prefix`` is set to ``!``. Defaults to ``False``. .. versionadded:: 1.7 tree_cls: Type[:class:`~discord.app_commands.CommandTree`] The type of application command tree to use. Defaults to :class:`~discord.app_commands.CommandTree`. .. versionadded:: 2.0 allowed_contexts: :class:`~discord.app_commands.AppCommandContext` The default allowed contexts that applies to all application commands in the application command tree. Note that you can override this on a per command basis. .. versionadded:: 2.4 allowed_installs: :class:`~discord.app_commands.AppInstallationType` The default allowed install locations that apply to all application commands in the application command tree. Note that you can override this on a per command basis. .. versionadded:: 2.4 N)r<r=r>__doc__r@rArBrHrHsaaF DrArHc:eZdZdZereejdeedddZ dSdS)rIa&This is similar to :class:`.Bot` except that it is inherited from :class:`discord.AutoShardedClient` instead. .. container:: operations .. describe:: async with x Asynchronously initialises the bot and automatically cleans. .. versionadded:: 2.0 NrfrlrmrgrnrhrorirprjrqrkrrrsrtrUnpack[_AutoShardedBotOptions]rOrwc dSrYr@) rarlrgrhrirjrkrsrs rBr{zAutoShardedBot.__init__s 3rA)rlrmrgrnrhrorirprjrqrkrrrsrtrrrOrw) r<r=r>rr rcrrrr{r@rArBrIrIsd    3;rs0#"""""  " 9999990000000011111111LLLLLLLLLLLLN........''''''000000++++++++pppppppppppppp------777777HSM3&'G($')ABOw 556JnE NMMMM!:KMMM  GCLL ge:&&&w"" 9 9 9 9####L((((((((  a-a-a-a-a-ja-a-a-H'd d d d d '7>d d d NWg7rA