hikari-arc 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

arc/utils/__init__.py

@@ -1,3 +1,54 @@
-from .hooks import bot_has_permissions, dm_only, guild_only, has_permissions, owner_only
+from .hooks import (
+    LimiterHook,
+    bot_has_permissions,
+    channel_limiter,
+    custom_limiter,
+    dm_only,
+    global_limiter,
+    guild_limiter,
+    guild_only,
+    has_permissions,
+    member_limiter,
+    owner_only,
+    user_limiter,
+)
+from .ratelimiter import RateLimiter, RateLimiterExhaustedError
 
-__all__ = ("guild_only", "owner_only", "dm_only", "has_permissions", "bot_has_permissions")
+__all__ = (
+    "guild_only",
+    "owner_only",
+    "dm_only",
+    "has_permissions",
+    "bot_has_permissions",
+    "global_limiter",
+    "guild_limiter",
+    "user_limiter",
+    "member_limiter",
+    "channel_limiter",
+    "custom_limiter",
+    "LimiterHook",
+    "RateLimiter",
+    "RateLimiterExhaustedError",
+)
+
+# MIT License
+#
+# Copyright (c) 2023-present hypergonial
+#
+# 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.

arc/utils/hooks/__init__.py

@@ -0,0 +1,25 @@
+from .basic import bot_has_permissions, dm_only, guild_only, has_permissions, owner_only
+from .limiters import (
+    LimiterHook,
+    channel_limiter,
+    custom_limiter,
+    global_limiter,
+    guild_limiter,
+    member_limiter,
+    user_limiter,
+)
+
+__all__ = (
+    "guild_only",
+    "owner_only",
+    "dm_only",
+    "has_permissions",
+    "bot_has_permissions",
+    "global_limiter",
+    "guild_limiter",
+    "channel_limiter",
+    "user_limiter",
+    "member_limiter",
+    "custom_limiter",
+    "LimiterHook",
+)

arc/utils/{hooks.py → hooks/basic.py}

@@ -1,9 +1,10 @@
+from __future__ import annotations
+
 import typing as t
 
 import hikari
 
 from arc.abc.hookable import HookResult
-from arc.context import Context
 from arc.errors import (
     BotMissingPermissionsError,
     DMOnlyError,
@@ -12,6 +13,9 @@ from arc.errors import (
     NotOwnerError,
 )
 
+if t.TYPE_CHECKING:
+    from arc.context import Context
+
 
 def guild_only(ctx: Context[t.Any]) -> HookResult:
     """A pre-execution hook that aborts the execution of a command if it is invoked outside of a guild.
@@ -127,3 +131,26 @@ def bot_has_permissions(perms: hikari.Permissions) -> t.Callable[[Context[t.Any]
         This hook requires the command to be invoked in a guild, and implies the [`guild_only`][arc.utils.hooks.guild_only] hook.
     """
     return lambda ctx: _bot_has_permissions(ctx, perms)
+
+
+# MIT License
+#
+# Copyright (c) 2023-present hypergonial
+#
+# 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.

arc/utils/hooks/limiters.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import typing as t
+
+from arc.abc.limiter import LimiterProto
+from arc.context.base import Context
+from arc.errors import UnderCooldownError
+from arc.internal.types import ClientT
+from arc.utils.ratelimiter import RateLimiter, RateLimiterExhaustedError
+
+__all__ = (
+    "LimiterHook",
+    "global_limiter",
+    "guild_limiter",
+    "channel_limiter",
+    "user_limiter",
+    "member_limiter",
+    "custom_limiter",
+)
+
+
+class LimiterHook(RateLimiter[Context[ClientT]], LimiterProto[ClientT]):
+    """The default implementation of a ratelimiter that can be used as a hook.
+
+    Parameters
+    ----------
+    period : float
+        The period, in seconds, after which the bucket resets.
+    limit : int
+        The amount of requests allowed in a bucket.
+    get_key_with : t.Callable[[Context[t.Any]], str]
+        A callable that returns a key for the ratelimiter bucket.
+
+    See Also
+    --------
+    - [`global_limiter`][arc.utils.hooks.limiters.global_limiter]
+    - [`guild_limiter`][arc.utils.hooks.limiters.guild_limiter]
+    - [`channel_limiter`][arc.utils.hooks.limiters.channel_limiter]
+    - [`user_limiter`][arc.utils.hooks.limiters.user_limiter]
+    - [`member_limiter`][arc.utils.hooks.limiters.member_limiter]
+    - [`custom_limiter`][arc.utils.hooks.limiters.custom_limiter]
+    """
+
+    async def acquire(self, ctx: Context[ClientT], *, wait: bool = True) -> None:
+        """Acquire a bucket, block execution if ratelimited and wait is True.
+
+        Parameters
+        ----------
+        ctx : Context[t.Any]
+            The context to evaluate the ratelimit under.
+        wait : bool
+            Determines if this call should block in
+            case of hitting a ratelimit.
+
+        Raises
+        ------
+        UnderCooldownError
+            If the ratelimiter is ratelimited and wait is False.
+        """
+        try:
+            return await super().acquire(ctx, wait=wait)
+        except RateLimiterExhaustedError as exc:
+            raise UnderCooldownError(
+                self, exc.retry_after, f"Command is under cooldown for '{exc.retry_after}' seconds."
+            ) from exc
+
+
+def global_limiter(period: float, limit: int) -> LimiterHook[t.Any]:
+    """Create a global ratelimiter.
+
+    This ratelimiter is shared across all invocation contexts.
+
+    Parameters
+    ----------
+    period : float
+        The period, in seconds, after which the bucket resets.
+    limit : int
+        The amount of requests allowed in a bucket.
+
+    Usage
+    -----
+    ```py
+    @arc.with_hook(arc.global_limiter(5.0, 1))
+    ```
+    """
+    return LimiterHook(period, limit, get_key_with=lambda _: "amongus")
+
+
+def guild_limiter(period: float, limit: int) -> LimiterHook[t.Any]:
+    """Create a guild ratelimiter.
+
+    This ratelimiter is shared across all contexts in a guild.
+
+    Parameters
+    ----------
+    period : float
+        The period, in seconds, after which the bucket resets.
+    limit : int
+        The amount of requests allowed in a bucket.
+
+    Usage
+    -----
+    ```py
+    @arc.with_hook(arc.guild_limiter(5.0, 1))
+    ```
+    """
+    return LimiterHook(period, limit, get_key_with=lambda ctx: str(ctx.guild_id))
+
+
+def channel_limiter(period: float, limit: int) -> LimiterHook[t.Any]:
+    """Create a channel ratelimiter.
+
+    This ratelimiter is shared across all contexts in a channel.
+
+    Parameters
+    ----------
+    period : float
+        The period, in seconds, after which the bucket resets.
+    limit : int
+        The amount of requests allowed in a bucket.
+
+    Usage
+    -----
+    ```py
+    @arc.with_hook(arc.channel_limiter(5.0, 1))
+    ```
+    """
+    return LimiterHook(period, limit, get_key_with=lambda ctx: str(ctx.channel_id))
+
+
+def user_limiter(period: float, limit: int) -> LimiterHook[t.Any]:
+    """Create a user ratelimiter.
+
+    This ratelimiter is shared across all contexts by a user.
+
+    Parameters
+    ----------
+    period : float
+        The period, in seconds, after which the bucket resets.
+    limit : int
+        The amount of requests allowed in a bucket.
+
+    Usage
+    -----
+    ```py
+    @arc.with_hook(arc.user_limiter(5.0, 1))
+    ```
+    """
+    return LimiterHook(period, limit, get_key_with=lambda ctx: str(ctx.author.id))
+
+
+def member_limiter(period: float, limit: int) -> LimiterHook[t.Any]:
+    """Create a member ratelimiter.
+
+    This ratelimiter is shared across all contexts by a member in a guild.
+    The same user in a different guild will be assigned a different bucket.
+
+    Parameters
+    ----------
+    period : float
+        The period, in seconds, after which the bucket resets.
+    limit : int
+        The amount of requests allowed in a bucket.
+
+    Usage
+    -----
+    ```py
+    @arc.with_hook(arc.member_limiter(5.0, 1))
+    ```
+    """
+    return LimiterHook(period, limit, get_key_with=lambda ctx: f"{ctx.author.id}:{ctx.guild_id}")
+
+
+def custom_limiter(period: float, limit: int, get_key_with: t.Callable[[Context[t.Any]], str]) -> LimiterHook[t.Any]:
+    """Create a ratelimiter with a custom key extraction function.
+
+    Parameters
+    ----------
+    period : float
+        The period, in seconds, after which the bucket resets.
+    limit : int
+        The amount of requests allowed in a bucket.
+    get_key_with : t.Callable[[Context[t.Any]], str]
+        A callable that returns a key for the ratelimiter bucket. This key is used to identify the bucket.
+        For instance, to create a ratelimiter that is shared across all contexts in a guild,
+        you would use `lambda ctx: str(ctx.guild_id)`.
+
+    Usage
+    -----
+    ```py
+    @arc.with_hook(arc.custom_limiter(5.0, 1, lambda ctx: str(ctx.guild_id)))
+    ```
+    """
+    return LimiterHook(period, limit, get_key_with=get_key_with)
+
+
+# MIT License
+#
+# Copyright (c) 2023-present hypergonial
+#
+# 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.

arc/utils/ratelimiter.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+import time
+import traceback
+import typing as t
+from collections import deque
+
+import attr
+
+from arc.abc.hookable import HookResult
+
+KeyT = t.TypeVar("KeyT")
+
+
+@attr.define(slots=True, kw_only=True)
+class _Bucket(t.Generic[KeyT]):
+    """Handles the ratelimiting of a single item. (E.g. a single user or a channel)."""
+
+    key: str
+    """The key of the bucket."""
+
+    reset_at: float
+    """The time at which the bucket resets."""
+
+    limiter: RateLimiter[KeyT]
+    """The limiter this bucket belongs to."""
+
+    _remaining: int = attr.field(alias="remaining")
+    """The amount of requests remaining until the bucket is exhausted."""
+
+    _queue: deque[asyncio.Event] = attr.field(factory=deque, init=False)
+    """A list of events to set as the iter task proceeds."""
+
+    _task: asyncio.Task[None] | None = attr.field(default=None, init=False)
+    """The task that is currently iterating over the queue."""
+
+    @classmethod
+    def for_limiter(cls, key: str, limiter: RateLimiter[KeyT]) -> _Bucket[KeyT]:
+        """Create a new bucket for a RateLimiter."""
+        return cls(key=key, limiter=limiter, reset_at=time.monotonic() + limiter.period, remaining=limiter.limit)
+
+    @property
+    def remaining(self) -> int:
+        """The amount of requests remaining until the bucket is exhausted."""
+        if self.reset_at <= time.monotonic():
+            self.reset()
+        return self._remaining
+
+    @remaining.setter
+    def remaining(self, value: int) -> None:
+        self._remaining = value
+
+    @property
+    def is_exhausted(self) -> bool:
+        """Return a boolean determining if the bucket is exhausted."""
+        return self.remaining <= 0 and self.reset_at > time.monotonic()
+
+    @property
+    def is_stale(self) -> bool:
+        """Return a boolean determining if the bucket is stale.
+        If a bucket is stale, it is no longer in use and can be purged.
+        """
+        return not self._queue and self.remaining == self.limiter.limit and (self._task is None or self._task.done())
+
+    def start_queue(self) -> None:
+        """Start the queue of a bucket.
+        This will start setting events in the queue until the bucket is ratelimited.
+        """
+        if self._task is None or self._task.done():
+            self._task = asyncio.create_task(self._iter_queue())
+
+    def reset(self) -> None:
+        """Reset the bucket."""
+        self.reset_at = time.monotonic() + self.limiter.period
+        self._remaining = self.limiter.limit
+
+    async def _iter_queue(self) -> None:
+        """Iterate over the queue and set events until exhausted."""
+        try:
+            while self._queue:
+                if self.remaining <= 0 and self.reset_at > time.monotonic():
+                    # Sleep until ratelimit expires
+                    await asyncio.sleep(self.reset_at - time.monotonic())
+                    self.reset()
+
+                # Set events while not ratelimited
+                while self.remaining > 0 and self._queue:
+                    self._queue.popleft().set()
+                    self._remaining -= 1
+
+        except Exception as e:
+            print(f"Task Exception was never retrieved: {e}", file=sys.stderr)
+            print(traceback.format_exc(), file=sys.stderr)
+
+
+class RateLimiter(t.Generic[KeyT]):
+    """A fixed window ratelimiter implementation.
+
+    It is generic over the type of object it extracts the key from (`KeyT`), and must also be given a key extraction function.
+    It can be used independently for any purpose, or can be used as a hook via [`LimiterHook`][arc.utils.hooks.limiters.LimiterHook].
+
+    !!! tip
+        If you're looking to use this ratelimiter implementation as a hook, see [`LimiterHook`][arc.utils.hooks.limiters.LimiterHook]
+        along with all the other built-in limiter hooks.
+
+    Parameters
+    ----------
+    period : float
+        The period, in seconds, after which the bucket resets.
+    limit : int
+        The amount of requests allowed in a bucket.
+    get_key_with : t.Callable[[Context[t.Any]], str]
+        A callable that returns a key for the ratelimiter bucket.
+    """
+
+    __slots__ = ("period", "limit", "_buckets", "_get_key", "_gc_task")
+
+    def __init__(self, period: float, limit: int, *, get_key_with: t.Callable[[KeyT], str]) -> None:
+        self.period: float = period
+        self.limit: int = limit
+        self._buckets: t.Dict[str, _Bucket[KeyT]] = {}
+        self._get_key: t.Callable[[KeyT], str] = get_key_with
+        self._gc_task: asyncio.Task[None] | None = None
+
+    def get_key(self, ctx: KeyT) -> str:
+        """Get key for ratelimiter bucket."""
+        return self._get_key(ctx)
+
+    def is_rate_limited(self, ctx: KeyT) -> bool:
+        """Returns a boolean determining if the ratelimiter is ratelimited or not.
+
+        Parameters
+        ----------
+        ctx : Context[t.Any]
+            The context to evaluate the ratelimit under.
+
+        Returns
+        -------
+        bool
+            A boolean determining if the ratelimiter is ratelimited or not.
+        """
+        now = time.monotonic()
+
+        if data := self._buckets.get(self.get_key(ctx)):
+            if data.reset_at <= now:
+                return False
+            return data._remaining <= 0
+        return False
+
+    def _start_gc(self) -> None:
+        """Start the garbage collector task if one is not running."""
+        if self._gc_task is None or self._gc_task.done():
+            self._gc_task = asyncio.create_task(self._gc())
+
+    async def _gc(self) -> None:
+        """Purge stale buckets."""
+        while self._buckets:
+            await asyncio.sleep(self.period + 1.0)
+            for bucket in list(self._buckets.values()):
+                if bucket.is_stale:
+                    del self._buckets[bucket.key]
+
+    async def acquire(self, ctx: KeyT, *, wait: bool = True) -> None:
+        """Acquire a bucket, block execution if ratelimited and wait is True.
+
+        Parameters
+        ----------
+        ctx : Context[t.Any]
+            The context to evaluate the ratelimit under.
+        wait : bool
+            Determines if this call should block in
+            case of hitting a ratelimit.
+
+        Raises
+        ------
+        RateLimiterExhaustedError
+            If the ratelimiter is ratelimited and wait is False.
+        """
+        event = asyncio.Event()
+
+        key = self.get_key(ctx)
+        # Get existing or insert new bucket
+        bucket = self._buckets.setdefault(key, _Bucket.for_limiter(key, self))
+
+        if bucket.is_exhausted and not wait:
+            raise RateLimiterExhaustedError(
+                self,
+                bucket.reset_at - time.monotonic(),
+                f"Ratelimited for {bucket.reset_at - time.monotonic()} seconds.",
+            )
+
+        bucket._queue.append(event)
+        bucket.start_queue()
+        self._start_gc()
+
+        if wait:
+            await event.wait()
+
+    async def __call__(self, ctx: KeyT) -> HookResult:
+        """Acquire a ratelimit, fail if ratelimited.
+
+        Parameters
+        ----------
+        ctx : Context[t.Any]
+            The context to evaluate the ratelimit under.
+
+        Returns
+        -------
+        HookResult
+            A hook result to conform to the limiter protocol.
+
+        Raises
+        ------
+        UnderCooldownError
+            If the ratelimiter is ratelimited.
+        """
+        await self.acquire(ctx, wait=False)
+        return HookResult()
+
+    def reset(self, ctx: KeyT) -> None:
+        """Reset the ratelimit for a given context."""
+        if bucket := self._buckets.get(self.get_key(ctx)):
+            bucket.reset()
+
+
+class RateLimiterExhaustedError(Exception):
+    """Raised when a [RateLimiter][arc.utils.ratelimiter.RateLimiter] is acquired while it is exhausted, and the
+    `wait` parameter is set to `False`.
+
+    Attributes
+    ----------
+    retry_after : float
+        The amount of time in seconds until the command is off cooldown.
+    limiter : arc.abc.limiter.LimiterProto
+        The limiter that was rate limited.
+    """
+
+    def __init__(self, limiter: RateLimiter[t.Any], retry_after: float, *args: t.Any) -> None:
+        self.retry_after = retry_after
+        self.limiter = limiter
+        super().__init__(*args)

{hikari_arc-0.4.0.dist-info → hikari_arc-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hikari-arc
-Version: 0.4.0
+Version: 0.6.0
 Summary: A command handler for hikari with a focus on type-safety and correctness.
 Home-page: https://github.com/hypergonial/hikari-arc
 Author: hypergonial
@@ -29,12 +29,17 @@ Requires-Dist: attrs >=23.1
 Requires-Dist: colorama ; sys_platform=="win32"
 Provides-Extra: dev
 Requires-Dist: ruff ==0.1.11 ; extra == 'dev'
-Requires-Dist: pyright ==1.1.344 ; extra == 'dev'
+Requires-Dist: pyright ==1.1.345 ; extra == 'dev'
 Requires-Dist: nox ==2023.4.22 ; extra == 'dev'
+Requires-Dist: typing-extensions ==4.9.0 ; extra == 'dev'
+Requires-Dist: pytest ==7.4.4 ; extra == 'dev'
+Requires-Dist: pytest-asyncio ==0.23.3 ; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: mkdocs-material[imaging] ~=9.5.3 ; extra == 'docs'
 Requires-Dist: mkdocs ~=1.5.3 ; extra == 'docs'
-Requires-Dist: mkdocstrings-python ~=1.7.5 ; extra == 'docs'
+Requires-Dist: mkdocstrings-python ~=1.8.0 ; extra == 'docs'
+Requires-Dist: black ~=23.12.1 ; extra == 'docs'
+Requires-Dist: griffe-inherited-docstrings ~=1.0.0 ; extra == 'docs'
 Provides-Extra: rest
 Requires-Dist: hikari[server] >=2.0.0.dev122 ; extra == 'rest'
 
@@ -81,10 +86,10 @@ bot = hikari.GatewayBot("TOKEN") # or hikari.RESTBot
 client = arc.GatewayClient(bot) # or arc.RESTClient
 
 @client.include
-@arc.slash_command(name="hi", description="Say hi!")
+@arc.slash_command("hi", "Say hi!")
 async def ping(
     ctx: arc.GatewayContext,
-    user: arc.Option[hikari.User, arc.UserParams(description="The user to say hi to.")]
+    user: arc.Option[hikari.User, arc.UserParams("The user to say hi to.")]
 ) -> None:
     await ctx.respond(f"Hey {user.mention}!")
 
@@ -105,9 +110,9 @@ See [Contributing](./CONTRIBUTING.md)
 `arc` is in large part a combination of all the parts I like in other command handlers, with my own spin on it. The following projects have inspired me and aided me greatly in the design of this library:
 
 - [`hikari-lightbulb`](https://github.com/tandemdude/hikari-lightbulb) - The library initially started as a reimagination of lightbulb, it inherits a similar project structure and terminology.
-- [`Tanjun`](https://github.com/FasterSpeeding/Tanjun) - For the idea of using `typing.Annotated` and dependency injection in a command handler. `arc` also uses the same dependency injection library, [`Alluka`](https://github.com/FasterSpeeding/Alluka), under the hood.
-- [`hikari-crescent`](https://github.com/hikari-crescent/hikari-crescent) The design of hooks is largely inspired by `crescent`.
-- [`FastAPI`](https://github.com/tiangolo/fastapi) - Some design ideas and most of the documentation configuration derives from `FastAPI`.
+- [`Tanjun`](https://github.com/FasterSpeeding/Tanjun) - For the idea of using `typing.Annotated` and [dependency injection](https://arc.hypergonial.com/guides/dependency_injection/) in a command handler. `arc` also uses the same dependency injection library, [`Alluka`](https://github.com/FasterSpeeding/Alluka), under the hood.
+- [`hikari-crescent`](https://github.com/hikari-crescent/hikari-crescent) The design of [hooks](https://arc.hypergonial.com/guides/hooks/) is largely inspired by `crescent`.
+- [`FastAPI`](https://github.com/tiangolo/fastapi) - Some design ideas and most of the [documentation](https://arc.hypergonial.com/) [configuration](https://github.com/hypergonial/hikari-arc/blob/main/mkdocs.yml) derives from `FastAPI`.
 
 ## Links