diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-hikari.spec | 413 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 415 insertions, 0 deletions
@@ -0,0 +1 @@ +/hikari-2.0.0.dev118.tar.gz diff --git a/python-hikari.spec b/python-hikari.spec new file mode 100644 index 0000000..699152f --- /dev/null +++ b/python-hikari.spec @@ -0,0 +1,413 @@ +%global _empty_manifest_terminate_build 0 +Name: python-hikari +Version: 2.0.0.dev118 +Release: 1 +Summary: A sane Discord API for Python 3 built on asyncio and good intentions +License: MIT +URL: https://github.com/hikari-py/hikari +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/37/da/098af837b975b2a56a7df3eafe6b0f68c5a96c487215c27bcf256068a7d0/hikari-2.0.0.dev118.tar.gz +BuildArch: noarch + +Requires: python3-aiohttp +Requires: python3-attrs +Requires: python3-colorlog +Requires: python3-multidict +Requires: python3-pynacl +Requires: python3-aiohttp[speedups] +Requires: python3-ciso8601 +Requires: python3-orjson + +%description +## Bots +Hikari provides two different default bot implementations to suit your needs: +- [GatewayBot](#gatewaybot) +- [RESTBot](#restbot) +### GatewayBot +A [`GatewayBot`](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/bot/#hikari.impl.bot.GatewayBot) +is one which will connect to Discord through the gateway and receive +events through there. A simple startup example could be the following: +```py +import hikari +bot = hikari.GatewayBot(token="...") +@bot.listen() +async def ping(event: hikari.GuildMessageCreateEvent) -> None: + """If a non-bot user mentions your bot, respond with 'Pong!'.""" + # Do not respond to bots nor webhooks pinging us, only user accounts + if not event.is_human: + return + me = bot.get_me() + if me.id in event.message.user_mentions_ids: + await event.message.respond("Pong!") +bot.run() +``` +This will only respond to messages created in guilds. You can use `DMMessageCreateEvent` instead to only listen on +DMs, or `MessageCreateEvent` to listen to both DMs and guild-based messages. A full list of events +can be found in the [events docs](https://docs.hikari-py.dev/en/stable/reference/hikari/events/). +If you wish to customize the intents being used in order to change which events your bot is notified about, then you +can pass the `intents` kwarg to the `GatewayBot` constructor: +```py +import hikari +# the default is to enable all unprivileged intents (all events that do not target the +# presence, activity of a specific member nor message content). +bot = hikari.GatewayBot(intents=hikari.Intents.ALL, token="...") +``` +The above example would enable all intents, thus enabling events relating to member presences to be received +(you'd need to whitelist your application first to be able to start the bot if you do this). +Events are determined by the type annotation on the event parameter, or alternatively as a type passed to the +`@bot.listen()` decorator, if you do not want to use type hints. +```py +import hikari +bot = hikari.GatewayBot("...") +@bot.listen() +async def ping(event: hikari.MessageCreateEvent): +# or +@bot.listen(hikari.MessageCreateEvent) +async def ping(event): +``` +### RESTBot +A [`RESTBot`](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/rest_bot/#hikari.impl.rest_bot.RESTBot) +spawns an interaction server to which Discord will **only** send interaction events, +which can be handled and responded to. +An example of a simple `RESTBot` could be the following: +```py +import asyncio +import hikari +# This function will handle the interactions received +async def handle_command(interaction: hikari.CommandInteraction): + # Create an initial response to be able to take longer to respond + yield interaction.build_deferred_response() + await asyncio.sleep(5) + # Edit the initial response + await interaction.edit_initial_response("Edit after 5 seconds!") +# Register the commands on startup. +# +# Note that this is not a nice way to manage this, as it is quite spammy +# to do it every time the bot is started. You can either use a command handler +# or only run this code in a script using `RESTApp` or add checks to not update +# the commands if there were no changes +async def create_commands(bot: hikari.RESTBot): + application = await bot.rest.fetch_application() + await bot.rest.set_application_commands( + application=application.id, + commands=[ + bot.rest.slash_command_builder("test", "My first test command!"), + ], + ) +bot = hikari.RESTBot( + token="...", + token_type="...", + public_key="...", +) +bot.add_startup_callback(create_commands) +bot.set_listener(hikari.CommandInteraction, handle_command) +bot.run() +``` +Unlike `GatewayBot`, registering listeners is done through `.set_listener`, and it takes in an interaction type +that the handler will take in. +Note that a bit of a setup is required to get the above code to work. You will need to host the project to +the World Wide Web (scary!) and then register the URL on the [Discord application portal](https://discord.com/developers/applications) +for your application under "Interactions Endpoint URL". +A quick way you can get your bot onto the internet and reachable by Discord (**for development environment only**) is +through a tool like [ngrok](https://ngrok.com/) or [localhost.run](https://localhost.run/). More information on how to +use them can be found in their respective websites. +### Common helpful features +Both implementations take in helpful arguments such as [customizing timeouts for requests](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/config/#hikari.impl.config.HTTPSettings.timeouts) +and [enabling a proxy](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/config/#hikari.impl.config.ProxySettings), +which are passed directly into the bot during initialization. +Also note that you could pass extra options to `bot.run` during development, for example: +```py +import hikari +bot = hikari.GatewayBot("...") +# or +bot = hikari.RESTBot("...", "...") +bot.run( + asyncio_debug=True, # enable asyncio debug to detect blocking and slow code. + coroutine_tracking_depth=20, # enable tracking of coroutines, makes some asyncio + # errors clearer. + propagate_interrupts=True, # Any OS interrupts get rethrown as errors. +) +``` +Many other helpful options exist for you to take advantage of if you wish. Links to the respective docs can be seen +below: +- [GatewayBot.run](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/bot/#hikari.impl.bot.GatewayBot.run) + +%package -n python3-hikari +Summary: A sane Discord API for Python 3 built on asyncio and good intentions +Provides: python-hikari +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-hikari +## Bots +Hikari provides two different default bot implementations to suit your needs: +- [GatewayBot](#gatewaybot) +- [RESTBot](#restbot) +### GatewayBot +A [`GatewayBot`](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/bot/#hikari.impl.bot.GatewayBot) +is one which will connect to Discord through the gateway and receive +events through there. A simple startup example could be the following: +```py +import hikari +bot = hikari.GatewayBot(token="...") +@bot.listen() +async def ping(event: hikari.GuildMessageCreateEvent) -> None: + """If a non-bot user mentions your bot, respond with 'Pong!'.""" + # Do not respond to bots nor webhooks pinging us, only user accounts + if not event.is_human: + return + me = bot.get_me() + if me.id in event.message.user_mentions_ids: + await event.message.respond("Pong!") +bot.run() +``` +This will only respond to messages created in guilds. You can use `DMMessageCreateEvent` instead to only listen on +DMs, or `MessageCreateEvent` to listen to both DMs and guild-based messages. A full list of events +can be found in the [events docs](https://docs.hikari-py.dev/en/stable/reference/hikari/events/). +If you wish to customize the intents being used in order to change which events your bot is notified about, then you +can pass the `intents` kwarg to the `GatewayBot` constructor: +```py +import hikari +# the default is to enable all unprivileged intents (all events that do not target the +# presence, activity of a specific member nor message content). +bot = hikari.GatewayBot(intents=hikari.Intents.ALL, token="...") +``` +The above example would enable all intents, thus enabling events relating to member presences to be received +(you'd need to whitelist your application first to be able to start the bot if you do this). +Events are determined by the type annotation on the event parameter, or alternatively as a type passed to the +`@bot.listen()` decorator, if you do not want to use type hints. +```py +import hikari +bot = hikari.GatewayBot("...") +@bot.listen() +async def ping(event: hikari.MessageCreateEvent): +# or +@bot.listen(hikari.MessageCreateEvent) +async def ping(event): +``` +### RESTBot +A [`RESTBot`](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/rest_bot/#hikari.impl.rest_bot.RESTBot) +spawns an interaction server to which Discord will **only** send interaction events, +which can be handled and responded to. +An example of a simple `RESTBot` could be the following: +```py +import asyncio +import hikari +# This function will handle the interactions received +async def handle_command(interaction: hikari.CommandInteraction): + # Create an initial response to be able to take longer to respond + yield interaction.build_deferred_response() + await asyncio.sleep(5) + # Edit the initial response + await interaction.edit_initial_response("Edit after 5 seconds!") +# Register the commands on startup. +# +# Note that this is not a nice way to manage this, as it is quite spammy +# to do it every time the bot is started. You can either use a command handler +# or only run this code in a script using `RESTApp` or add checks to not update +# the commands if there were no changes +async def create_commands(bot: hikari.RESTBot): + application = await bot.rest.fetch_application() + await bot.rest.set_application_commands( + application=application.id, + commands=[ + bot.rest.slash_command_builder("test", "My first test command!"), + ], + ) +bot = hikari.RESTBot( + token="...", + token_type="...", + public_key="...", +) +bot.add_startup_callback(create_commands) +bot.set_listener(hikari.CommandInteraction, handle_command) +bot.run() +``` +Unlike `GatewayBot`, registering listeners is done through `.set_listener`, and it takes in an interaction type +that the handler will take in. +Note that a bit of a setup is required to get the above code to work. You will need to host the project to +the World Wide Web (scary!) and then register the URL on the [Discord application portal](https://discord.com/developers/applications) +for your application under "Interactions Endpoint URL". +A quick way you can get your bot onto the internet and reachable by Discord (**for development environment only**) is +through a tool like [ngrok](https://ngrok.com/) or [localhost.run](https://localhost.run/). More information on how to +use them can be found in their respective websites. +### Common helpful features +Both implementations take in helpful arguments such as [customizing timeouts for requests](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/config/#hikari.impl.config.HTTPSettings.timeouts) +and [enabling a proxy](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/config/#hikari.impl.config.ProxySettings), +which are passed directly into the bot during initialization. +Also note that you could pass extra options to `bot.run` during development, for example: +```py +import hikari +bot = hikari.GatewayBot("...") +# or +bot = hikari.RESTBot("...", "...") +bot.run( + asyncio_debug=True, # enable asyncio debug to detect blocking and slow code. + coroutine_tracking_depth=20, # enable tracking of coroutines, makes some asyncio + # errors clearer. + propagate_interrupts=True, # Any OS interrupts get rethrown as errors. +) +``` +Many other helpful options exist for you to take advantage of if you wish. Links to the respective docs can be seen +below: +- [GatewayBot.run](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/bot/#hikari.impl.bot.GatewayBot.run) + +%package help +Summary: Development documents and examples for hikari +Provides: python3-hikari-doc +%description help +## Bots +Hikari provides two different default bot implementations to suit your needs: +- [GatewayBot](#gatewaybot) +- [RESTBot](#restbot) +### GatewayBot +A [`GatewayBot`](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/bot/#hikari.impl.bot.GatewayBot) +is one which will connect to Discord through the gateway and receive +events through there. A simple startup example could be the following: +```py +import hikari +bot = hikari.GatewayBot(token="...") +@bot.listen() +async def ping(event: hikari.GuildMessageCreateEvent) -> None: + """If a non-bot user mentions your bot, respond with 'Pong!'.""" + # Do not respond to bots nor webhooks pinging us, only user accounts + if not event.is_human: + return + me = bot.get_me() + if me.id in event.message.user_mentions_ids: + await event.message.respond("Pong!") +bot.run() +``` +This will only respond to messages created in guilds. You can use `DMMessageCreateEvent` instead to only listen on +DMs, or `MessageCreateEvent` to listen to both DMs and guild-based messages. A full list of events +can be found in the [events docs](https://docs.hikari-py.dev/en/stable/reference/hikari/events/). +If you wish to customize the intents being used in order to change which events your bot is notified about, then you +can pass the `intents` kwarg to the `GatewayBot` constructor: +```py +import hikari +# the default is to enable all unprivileged intents (all events that do not target the +# presence, activity of a specific member nor message content). +bot = hikari.GatewayBot(intents=hikari.Intents.ALL, token="...") +``` +The above example would enable all intents, thus enabling events relating to member presences to be received +(you'd need to whitelist your application first to be able to start the bot if you do this). +Events are determined by the type annotation on the event parameter, or alternatively as a type passed to the +`@bot.listen()` decorator, if you do not want to use type hints. +```py +import hikari +bot = hikari.GatewayBot("...") +@bot.listen() +async def ping(event: hikari.MessageCreateEvent): +# or +@bot.listen(hikari.MessageCreateEvent) +async def ping(event): +``` +### RESTBot +A [`RESTBot`](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/rest_bot/#hikari.impl.rest_bot.RESTBot) +spawns an interaction server to which Discord will **only** send interaction events, +which can be handled and responded to. +An example of a simple `RESTBot` could be the following: +```py +import asyncio +import hikari +# This function will handle the interactions received +async def handle_command(interaction: hikari.CommandInteraction): + # Create an initial response to be able to take longer to respond + yield interaction.build_deferred_response() + await asyncio.sleep(5) + # Edit the initial response + await interaction.edit_initial_response("Edit after 5 seconds!") +# Register the commands on startup. +# +# Note that this is not a nice way to manage this, as it is quite spammy +# to do it every time the bot is started. You can either use a command handler +# or only run this code in a script using `RESTApp` or add checks to not update +# the commands if there were no changes +async def create_commands(bot: hikari.RESTBot): + application = await bot.rest.fetch_application() + await bot.rest.set_application_commands( + application=application.id, + commands=[ + bot.rest.slash_command_builder("test", "My first test command!"), + ], + ) +bot = hikari.RESTBot( + token="...", + token_type="...", + public_key="...", +) +bot.add_startup_callback(create_commands) +bot.set_listener(hikari.CommandInteraction, handle_command) +bot.run() +``` +Unlike `GatewayBot`, registering listeners is done through `.set_listener`, and it takes in an interaction type +that the handler will take in. +Note that a bit of a setup is required to get the above code to work. You will need to host the project to +the World Wide Web (scary!) and then register the URL on the [Discord application portal](https://discord.com/developers/applications) +for your application under "Interactions Endpoint URL". +A quick way you can get your bot onto the internet and reachable by Discord (**for development environment only**) is +through a tool like [ngrok](https://ngrok.com/) or [localhost.run](https://localhost.run/). More information on how to +use them can be found in their respective websites. +### Common helpful features +Both implementations take in helpful arguments such as [customizing timeouts for requests](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/config/#hikari.impl.config.HTTPSettings.timeouts) +and [enabling a proxy](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/config/#hikari.impl.config.ProxySettings), +which are passed directly into the bot during initialization. +Also note that you could pass extra options to `bot.run` during development, for example: +```py +import hikari +bot = hikari.GatewayBot("...") +# or +bot = hikari.RESTBot("...", "...") +bot.run( + asyncio_debug=True, # enable asyncio debug to detect blocking and slow code. + coroutine_tracking_depth=20, # enable tracking of coroutines, makes some asyncio + # errors clearer. + propagate_interrupts=True, # Any OS interrupts get rethrown as errors. +) +``` +Many other helpful options exist for you to take advantage of if you wish. Links to the respective docs can be seen +below: +- [GatewayBot.run](https://docs.hikari-py.dev/en/stable/reference/hikari/impl/bot/#hikari.impl.bot.GatewayBot.run) + +%prep +%autosetup -n hikari-2.0.0.dev118 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-hikari -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Tue Apr 11 2023 Python_Bot <Python_Bot@openeuler.org> - 2.0.0.dev118-1 +- Package Spec generated @@ -0,0 +1 @@ +b696d6a4ac5c7458e11419bac170236c hikari-2.0.0.dev118.tar.gz |