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

arc/utils/hooks/limiters.py

@@ -1,25 +1,15 @@
 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
 from arc.abc.limiter import LimiterProto
+from arc.context.base import Context
 from arc.errors import UnderCooldownError
 from arc.internal.types import ClientT
-
-if t.TYPE_CHECKING:
-    from arc.context.base import Context
-
+from arc.utils.ratelimiter import RateLimiter, RateLimiterExhaustedError
 
 __all__ = (
-    "RateLimiter",
+    "LimiterHook",
     "global_limiter",
     "guild_limiter",
     "channel_limiter",
@@ -29,89 +19,8 @@ __all__ = (
 )
 
 
-@attr.define(slots=True, kw_only=True)
-class _Bucket(t.Generic[ClientT]):
-    """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[ClientT]
-    """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[ClientT]) -> _Bucket[ClientT]:
-        """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(LimiterProto[ClientT]):
-    """The default implementation of a ratelimiter.
+class LimiterHook(RateLimiter[Context[ClientT]], LimiterProto[ClientT]):
+    """The default implementation of a ratelimiter that can be used as a hook.
 
     Parameters
     ----------
@@ -119,58 +28,20 @@ class RateLimiter(LimiterProto[ClientT]):
         The period, in seconds, after which the bucket resets.
     limit : int
         The amount of requests allowed in a bucket.
-    get_key_with : Callable[[Context[t.Any]], str]
+    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")
-
-    def __init__(self, period: float, limit: int, *, get_key_with: t.Callable[[Context[t.Any]], str]) -> None:
-        self.period: float = period
-        self.limit: int = limit
-        self._buckets: t.Dict[str, _Bucket[ClientT]] = {}
-        self._get_key: t.Callable[[Context[t.Any]], str] = get_key_with
-        self._gc_task: asyncio.Task[None] | None = None
 
-    def get_key(self, ctx: Context[t.Any]) -> str:
-        """Get key for ratelimiter bucket."""
-        return self._get_key(ctx)
-
-    def is_rate_limited(self, ctx: Context[t.Any]) -> bool:
-        """Returns a boolean determining if the ratelimiter is ratelimited or not.
-
-        Parameters
-        ----------
-        ctx : Context[t.Any]
-            The context to evaluate the ratelimit under.
+    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]
+    """
 
-        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: Context[t.Any], *, wait: bool = True) -> None:
+    async def acquire(self, ctx: Context[ClientT], *, wait: bool = True) -> None:
         """Acquire a bucket, block execution if ratelimited and wait is True.
 
         Parameters
@@ -186,54 +57,15 @@ class RateLimiter(LimiterProto[ClientT]):
         UnderCooldownError
             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:
+        try:
+            return await super().acquire(ctx, wait=wait)
+        except RateLimiterExhaustedError as exc:
             raise UnderCooldownError(
-                self,
-                bucket.reset_at - time.monotonic(),
-                f"Ratelimited for {bucket.reset_at - time.monotonic()} seconds.",
-            )
+                self, exc.retry_after, f"Command is under cooldown for '{exc.retry_after}' seconds."
+            ) from exc
 
-        bucket._queue.append(event)
-        bucket.start_queue()
-        self._start_gc()
-
-        if wait:
-            await event.wait()
-
-    async def __call__(self, ctx: Context[t.Any]) -> 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: Context[t.Any]) -> None:
-        """Reset the ratelimit for a given context."""
-        if bucket := self._buckets.get(self.get_key(ctx)):
-            bucket.reset()
-
-
-def global_limiter(period: float, limit: int) -> RateLimiter[t.Any]:
+def global_limiter(period: float, limit: int) -> LimiterHook[t.Any]:
     """Create a global ratelimiter.
 
     This ratelimiter is shared across all invocation contexts.
@@ -244,11 +76,17 @@ def global_limiter(period: float, limit: int) -> RateLimiter[t.Any]:
         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 RateLimiter(period, limit, get_key_with=lambda _: "amongus")
+    return LimiterHook(period, limit, get_key_with=lambda _: "amongus")
 
 
-def guild_limiter(period: float, limit: int) -> RateLimiter[t.Any]:
+def guild_limiter(period: float, limit: int) -> LimiterHook[t.Any]:
     """Create a guild ratelimiter.
 
     This ratelimiter is shared across all contexts in a guild.
@@ -259,11 +97,17 @@ def guild_limiter(period: float, limit: int) -> RateLimiter[t.Any]:
         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 RateLimiter(period, limit, get_key_with=lambda ctx: str(ctx.guild_id))
+    return LimiterHook(period, limit, get_key_with=lambda ctx: str(ctx.guild_id))
 
 
-def channel_limiter(period: float, limit: int) -> RateLimiter[t.Any]:
+def channel_limiter(period: float, limit: int) -> LimiterHook[t.Any]:
     """Create a channel ratelimiter.
 
     This ratelimiter is shared across all contexts in a channel.
@@ -274,11 +118,17 @@ def channel_limiter(period: float, limit: int) -> RateLimiter[t.Any]:
         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 RateLimiter(period, limit, get_key_with=lambda ctx: str(ctx.channel_id))
+    return LimiterHook(period, limit, get_key_with=lambda ctx: str(ctx.channel_id))
 
 
-def user_limiter(period: float, limit: int) -> RateLimiter[t.Any]:
+def user_limiter(period: float, limit: int) -> LimiterHook[t.Any]:
     """Create a user ratelimiter.
 
     This ratelimiter is shared across all contexts by a user.
@@ -289,11 +139,17 @@ def user_limiter(period: float, limit: int) -> RateLimiter[t.Any]:
         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 RateLimiter(period, limit, get_key_with=lambda ctx: str(ctx.author.id))
+    return LimiterHook(period, limit, get_key_with=lambda ctx: str(ctx.author.id))
 
 
-def member_limiter(period: float, limit: int) -> RateLimiter[t.Any]:
+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.
@@ -305,11 +161,17 @@ def member_limiter(period: float, limit: int) -> RateLimiter[t.Any]:
         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 RateLimiter(period, limit, get_key_with=lambda ctx: f"{ctx.author.id}:{ctx.guild_id}")
+    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]) -> RateLimiter[t.Any]:
+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
@@ -318,12 +180,18 @@ def custom_limiter(period: float, limit: int, get_key_with: t.Callable[[Context[
         The period, in seconds, after which the bucket resets.
     limit : int
         The amount of requests allowed in a bucket.
-    get_key_with : Callable[[Context[t.Any]], str]
+    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 RateLimiter(period, limit, get_key_with=get_key_with)
+    return LimiterHook(period, limit, get_key_with=get_key_with)
 
 
 # MIT License

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.5.0.dist-info → hikari_arc-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hikari-arc
-Version: 0.5.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'
 
@@ -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