%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