requestflow 0.1.0__tar.gz → 0.1.1__tar.gz

{requestflow-0.1.0/src/requestflow.egg-info → requestflow-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: requestflow
-Version: 0.1.0
+Version: 0.1.1
 Summary: stop getting 429 ratelimited like an amateur. high-performance http scheduling and pacing for discord.py.
 Author: requestflow
 License-Expression: MIT

{requestflow-0.1.0 → requestflow-0.1.1}/pyproject.toml

@@ -1,73 +1,73 @@
-[build-system]
-requires = ["setuptools>=61.0.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "requestflow"
-version = "0.1.0"
-description = "stop getting 429 ratelimited like an amateur. high-performance http scheduling and pacing for discord.py."
-readme = "README.md"
-requires-python = ">=3.11"
-license = "MIT"
-authors = [
-    { name = "requestflow" }
-]
-keywords = [
-    "discord",
-    "discord.py",
-    "http",
-    "ratelimit",
-    "queue",
-    "scheduler",
-    "asyncio",
-    "performance"
-]
-classifiers = [
-    "Development Status :: 5 - Production/Stable",
-    "Framework :: AsyncIO",
-    "Intended Audience :: Developers",
-    "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-    "Topic :: Communications :: Chat",
-    "Topic :: Internet :: WWW/HTTP",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Typing :: Typed"
-]
-dependencies = [
-    "discord.py>=2.0.0"
-]
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.0.0",
-    "pytest-asyncio>=0.23.0",
-    "coverage>=7.0.0",
-    "setuptools>=61.0.0",
-    "wheel"
-]
-
-[project.urls]
-Repository = "https://github.com/snipe1337/requestflow"
-Issues = "https://github.com/snipe1337/requestflow/issues"
-Community = "https://discord.gg/cse"
-Support = "https://discord.gg/cse"
-
-[tool.setuptools.packages.find]
-where = ["src"]
-
-[tool.setuptools.package-data]
-requestflow = ["py.typed"]
-
-[tool.pytest.ini_options]
-minversion = "8.0"
-testpaths = ["tests"]
-pythonpath = ["src"]
-asyncio_mode = "auto"
-asyncio_default_fixture_loop_scope = "function"
-filterwarnings = [
-    "ignore::DeprecationWarning",
-    "ignore::UserWarning"
-]
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "requestflow"
+version = "0.1.1"
+description = "stop getting 429 ratelimited like an amateur. high-performance http scheduling and pacing for discord.py."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [
+    { name = "requestflow" }
+]
+keywords = [
+    "discord",
+    "discord.py",
+    "http",
+    "ratelimit",
+    "queue",
+    "scheduler",
+    "asyncio",
+    "performance"
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Communications :: Chat",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed"
+]
+dependencies = [
+    "discord.py>=2.0.0"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "coverage>=7.0.0",
+    "setuptools>=61.0.0",
+    "wheel"
+]
+
+[project.urls]
+Repository = "https://github.com/snipe1337/requestflow"
+Issues = "https://github.com/snipe1337/requestflow/issues"
+Community = "https://discord.gg/cse"
+Support = "https://discord.gg/cse"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+requestflow = ["py.typed"]
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+testpaths = ["tests"]
+pythonpath = ["src"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+filterwarnings = [
+    "ignore::DeprecationWarning",
+    "ignore::UserWarning"
+]

{requestflow-0.1.0 → requestflow-0.1.1}/src/requestflow/__init__.py

@@ -10,6 +10,6 @@ from requestflow.priorities import Priority
 from requestflow.queue import RequestQueue
 from requestflow.ratelimit import GlobalRateLimiter, RateLimitCoordinator, RouteBucketCoordinator
 from requestflow.scheduler import RequestScheduler
-__version__ = '0.1.0'
+__version__ = '0.1.1'
 __all__ = ['__version__', 'requestflow', 'priority', 'overloadpolicy', 'pacingstrategy', 'retrypolicy', 'requestmetrics', 'metricssnapshot', 'requestitem', 'requestscheduler', 'requestqueue', 'requestexecutor', 'ratelimitcoordinator', 'globalratelimiter', 'routebucketcoordinator',
            'inflightdeduplicator', 'resultcache', 'discordhttpadapter', 'attach_to_bot', 'requestflowerror', 'queuefullerror', 'schedulerclosederror', 'schedulernotstartederror', 'requesttimeouterror', 'ratelimitexceedederror', 'integrationerror', 'unsupporteddiscordversionerror', 'operationcancellederror']

{requestflow-0.1.0 → requestflow-0.1.1}/src/requestflow/flow.py

@@ -64,7 +64,7 @@ class RequestFlow:
     async def update_rate(self, new_rate: float) -> None:
         await self.scheduler.rate_coordinator.global_limiter.update_rate(new_rate)
 
-    async def submit(self, operation: Callable[..., Coroutine[Any, Any, T]], *args: Any, priority: Union[Priority, str, int] = Priority.NORMAL, guild_id: Optional[int] = None, route_key: Optional[str] = None, is_interaction: bool = False, dedup_key: Optional[str] = None, timeout: Optional[float] = None, enqueue_timeout: Optional[float] = None, **kwargs: Any) -> T:
+    async def submit(self, operation: Callable[..., Coroutine[Any, Any, T]], *args: Any, priority: Union[Priority, str, int] = Priority.NORMAL, guild_id: Optional[Union[int, str]] = None, route_key: Optional[str] = None, is_interaction: bool = False, dedup_key: Optional[str] = None, timeout: Optional[float] = None, enqueue_timeout: Optional[float] = None, **kwargs: Any) -> T:
         parsed_priority = Priority.from_value(priority)
         if dedup_key is not None:
             async def run_single() -> T:

{requestflow-0.1.0 → requestflow-0.1.1}/src/requestflow/integrations/discord_py.py

@@ -1,115 +1,209 @@
-import functools
-import inspect
-from typing import Any, Callable, Optional, Sequence, Union
-try:
-    import discord
-    import discord.http
-    HAS_DISCORD = True
-except ImportError:
-    HAS_DISCORD = False
-from requestflow.exceptions import IntegrationError, UnsupportedDiscordVersionError
-from requestflow.priorities import Priority
-from requestflow.scheduler import RequestScheduler
-
-
-class DiscordHTTPAdapter:
-    MIN_SUPPORTED_DISCORD_VERSION = (2, 0, 0)
-
-    def __init__(self, scheduler: RequestScheduler) -> None:
-        self.scheduler: RequestScheduler = scheduler
-        self._attached_clients: set = set()
-        self._original_requests: dict = {}
-
-    @classmethod
-    def verify_compatibility(cls) -> None:
-        if not HAS_DISCORD:
-            raise IntegrationError(
-                'discord.py is not installed in the current environment.')
-        version_str = getattr(discord, '__version__', 'unknown')
-        try:
-            parts = version_str.split('.')
-            major = int(parts[0])
-            minor = int(parts[1].rstrip('abcdefghijklmnopqrstuvwxyz'))
-            if major < 2:
-                raise UnsupportedDiscordVersionError(
-                    f'requestflow requires discord.py >= 2.0.0, but found {version_str}.', detected_version=version_str)
-        except (ValueError, IndexError):
-            if not hasattr(discord.http, 'httpclient') or not hasattr(discord.http, 'route'):
-                raise UnsupportedDiscordVersionError(
-                    f'unsupported discord.py layout or version: {version_str}.', detected_version=version_str)
-
-    def attach(self, client: Any) -> None:
-        self.verify_compatibility()
-        http_client = getattr(client, 'http', None)
-        if http_client is None:
-            if isinstance(client, getattr(discord.http, 'httpclient', object)):
-                http_client = client
-            else:
-                raise IntegrationError(
-                    f"target object {type(client).__name__} does not have an 'http' attribute.")
-        if not hasattr(http_client, 'request') or not callable(http_client.request):
-            raise IntegrationError(
-                f"http client {type(http_client).__name__} has no callable 'request' method.")
-        if http_client in self._attached_clients:
-            return
-        original_request = http_client.request
-        self._original_requests[http_client] = original_request
-
-        @functools.wraps(original_request)
-        async def scheduled_request(route: Any, *args: Any, **kwargs: Any) -> Any:
-            guild_id = getattr(route, 'guild_id', None)
-            route_path = getattr(route, 'path', '')
-            route_key = getattr(
-                route, 'key', f"{getattr(route, 'method', 'GET')} {route_path}")
-            is_interaction = bool(
-                route_path and '/interactions/' in route_path)
-            if is_interaction:
-                priority = Priority.CRITICAL
-            elif getattr(route, 'method', '') == 'DELETE':
-                priority = Priority.HIGH
-            else:
-                priority = Priority.NORMAL
-
-            async def run_http() -> Any:
-                try:
-                    return await original_request(route, *args, **kwargs)
-                except getattr(discord, 'ratelimited', Exception) as exc:
-                    retry_after = getattr(exc, 'retry_after', 0.0)
-                    if retry_after > 0:
-                        self.scheduler.rate_coordinator.handle_429(
-                            retry_after, is_global=False, route_key=route_key)
-                        self.scheduler.metrics.record_429(is_global=False)
-                    raise
-                except getattr(discord, 'httpexception', Exception) as exc:
-                    if getattr(exc, 'status', None) == 429:
-                        retry_after = 1.0
-                        if hasattr(exc, 'response') and hasattr(exc.response, 'headers'):
-                            retry_after = float(
-                                exc.response.headers.get('Retry-After', 1.0))
-                        self.scheduler.rate_coordinator.handle_429(
-                            retry_after, is_global=False, route_key=route_key)
-                        self.scheduler.metrics.record_429(is_global=False)
-                    raise
-            return await self.scheduler.submit(run_http, priority=priority, guild_id=guild_id, route_key=route_key, is_interaction=is_interaction)
-        http_client.request = scheduled_request
-        self._attached_clients.add(http_client)
-
-    def detach(self, client: Any) -> None:
-        http_client = getattr(client, 'http', client)
-        if http_client in self._attached_clients:
-            original = self._original_requests.pop(http_client, None)
-            if original:
-                http_client.request = original
-            self._attached_clients.remove(http_client)
-
-    def detach_all(self) -> None:
-        for http_client, original in list(self._original_requests.items()):
-            http_client.request = original
-        self._attached_clients.clear()
-        self._original_requests.clear()
-
-
-def attach_to_bot(scheduler: RequestScheduler, bot: Any) -> DiscordHTTPAdapter:
-    adapter = DiscordHTTPAdapter(scheduler)
-    adapter.attach(bot)
-    return adapter
+import functools
+import inspect
+import re
+from typing import Any, Callable, Optional, Sequence, Union
+try:
+    import discord
+    import discord.http
+    HAS_DISCORD = True
+except ImportError:
+    HAS_DISCORD = False
+from requestflow.exceptions import IntegrationError, UnsupportedDiscordVersionError
+from requestflow.priorities import Priority
+from requestflow.scheduler import RequestScheduler
+
+
+def extract_resource_id(route: Any, client: Optional[Any] = None) -> Optional[Union[int, str]]:
+    guild_id = getattr(route, 'guild_id', None)
+    if guild_id is None and hasattr(route, 'parameters') and isinstance(route.parameters, dict):
+        guild_id = route.parameters.get('guild_id')
+    if guild_id is not None:
+        try:
+            return int(guild_id)
+        except (ValueError, TypeError):
+            return guild_id
+    channel_id = getattr(route, 'channel_id', None)
+    if channel_id is None and hasattr(route, 'parameters') and isinstance(route.parameters, dict):
+        channel_id = route.parameters.get('channel_id')
+    if channel_id is not None:
+        if client is not None:
+            get_channel = getattr(client, 'get_channel', None)
+            if callable(get_channel):
+                try:
+                    ch = get_channel(int(channel_id))
+                    if ch is not None:
+                        g = getattr(ch, 'guild', None)
+                        if g is not None and getattr(g, 'id', None) is not None:
+                            return int(g.id)
+                except Exception:
+                    pass
+            state = getattr(client, '_connection', None) or getattr(client, '_state', None)
+            if state is not None:
+                state_get_channel = getattr(state, 'get_channel', None)
+                if callable(state_get_channel):
+                    try:
+                        ch = state_get_channel(int(channel_id))
+                        if ch is not None:
+                            g = getattr(ch, 'guild', None)
+                            if g is not None and getattr(g, 'id', None) is not None:
+                                return int(g.id)
+                    except Exception:
+                        pass
+        try:
+            return int(channel_id)
+        except (ValueError, TypeError):
+            return str(channel_id)
+    webhook_id = getattr(route, 'webhook_id', None)
+    if webhook_id is None and hasattr(route, 'parameters') and isinstance(route.parameters, dict):
+        webhook_id = route.parameters.get('webhook_id')
+    if webhook_id is not None:
+        try:
+            return int(webhook_id)
+        except (ValueError, TypeError):
+            return str(webhook_id)
+    path = getattr(route, 'path', '') or ''
+    if '/guilds/' in path:
+        m = re.search(r'/guilds/(\d+)', path)
+        if m:
+            return int(m.group(1))
+    if '/channels/' in path:
+        m = re.search(r'/channels/(\d+)', path)
+        if m:
+            cid = int(m.group(1))
+            if client is not None:
+                get_channel = getattr(client, 'get_channel', None)
+                if callable(get_channel):
+                    try:
+                        ch = get_channel(cid)
+                        if ch is not None:
+                            g = getattr(ch, 'guild', None)
+                            if g is not None and getattr(g, 'id', None) is not None:
+                                return int(g.id)
+                    except Exception:
+                        pass
+                state = getattr(client, '_connection', None) or getattr(client, '_state', None)
+                if state is not None:
+                    state_get_channel = getattr(state, 'get_channel', None)
+                    if callable(state_get_channel):
+                        try:
+                            ch = state_get_channel(cid)
+                            if ch is not None:
+                                g = getattr(ch, 'guild', None)
+                                if g is not None and getattr(g, 'id', None) is not None:
+                                    return int(g.id)
+                        except Exception:
+                            pass
+            return cid
+    if '/webhooks/' in path:
+        m = re.search(r'/webhooks/(\d+)', path)
+        if m:
+            return int(m.group(1))
+    return None
+
+
+class DiscordHTTPAdapter:
+    MIN_SUPPORTED_DISCORD_VERSION = (2, 0, 0)
+
+    def __init__(self, scheduler: RequestScheduler) -> None:
+        self.scheduler: RequestScheduler = scheduler
+        self._attached_clients: set = set()
+        self._original_requests: dict = {}
+        self._bot_map: dict = {}
+
+    @classmethod
+    def verify_compatibility(cls) -> None:
+        if not HAS_DISCORD:
+            raise IntegrationError(
+                'discord.py is not installed in the current environment.')
+        version_str = getattr(discord, '__version__', 'unknown')
+        try:
+            parts = version_str.split('.')
+            major = int(parts[0])
+            minor = int(parts[1].rstrip('abcdefghijklmnopqrstuvwxyz'))
+            if major < 2:
+                raise UnsupportedDiscordVersionError(
+                    f'requestflow requires discord.py >= 2.0.0, but found {version_str}.', detected_version=version_str)
+        except (ValueError, IndexError):
+            if not hasattr(discord.http, 'httpclient') or not hasattr(discord.http, 'route'):
+                raise UnsupportedDiscordVersionError(
+                    f'unsupported discord.py layout or version: {version_str}.', detected_version=version_str)
+
+    def attach(self, client: Any) -> None:
+        self.verify_compatibility()
+        http_client = getattr(client, 'http', None)
+        if http_client is None:
+            if isinstance(client, getattr(discord.http, 'httpclient', object)):
+                http_client = client
+            else:
+                raise IntegrationError(
+                    f"target object {type(client).__name__} does not have an 'http' attribute.")
+        if not hasattr(http_client, 'request') or not callable(http_client.request):
+            raise IntegrationError(
+                f"http client {type(http_client).__name__} has no callable 'request' method.")
+        if http_client in self._attached_clients:
+            return
+        self._bot_map[http_client] = client
+        original_request = http_client.request
+        self._original_requests[http_client] = original_request
+
+        @functools.wraps(original_request)
+        async def scheduled_request(route: Any, *args: Any, **kwargs: Any) -> Any:
+            bot_client = self._bot_map.get(http_client)
+            guild_id = extract_resource_id(route, bot_client)
+            route_path = getattr(route, 'path', '')
+            route_key = getattr(
+                route, 'key', f"{getattr(route, 'method', 'GET')} {route_path}")
+            is_interaction = bool(
+                route_path and '/interactions/' in route_path)
+            if is_interaction:
+                priority = Priority.CRITICAL
+            elif getattr(route, 'method', '') == 'DELETE':
+                priority = Priority.HIGH
+            else:
+                priority = Priority.NORMAL
+
+            async def run_http() -> Any:
+                try:
+                    return await original_request(route, *args, **kwargs)
+                except getattr(discord, 'ratelimited', Exception) as exc:
+                    retry_after = getattr(exc, 'retry_after', 0.0)
+                    if retry_after > 0:
+                        self.scheduler.rate_coordinator.handle_429(
+                            retry_after, is_global=False, route_key=route_key)
+                        self.scheduler.metrics.record_429(is_global=False)
+                    raise
+                except getattr(discord, 'httpexception', Exception) as exc:
+                    if getattr(exc, 'status', None) == 429:
+                        retry_after = 1.0
+                        if hasattr(exc, 'response') and hasattr(exc.response, 'headers'):
+                            retry_after = float(
+                                exc.response.headers.get('Retry-After', 1.0))
+                        self.scheduler.rate_coordinator.handle_429(
+                            retry_after, is_global=False, route_key=route_key)
+                        self.scheduler.metrics.record_429(is_global=False)
+                    raise
+            return await self.scheduler.submit(run_http, priority=priority, guild_id=guild_id, route_key=route_key, is_interaction=is_interaction)
+        http_client.request = scheduled_request
+        self._attached_clients.add(http_client)
+
+    def detach(self, client: Any) -> None:
+        http_client = getattr(client, 'http', client)
+        if http_client in self._attached_clients:
+            self._bot_map.pop(http_client, None)
+            original = self._original_requests.pop(http_client, None)
+            if original:
+                http_client.request = original
+            self._attached_clients.remove(http_client)
+
+    def detach_all(self) -> None:
+        for http_client, original in list(self._original_requests.items()):
+            http_client.request = original
+        self._attached_clients.clear()
+        self._original_requests.clear()
+        self._bot_map.clear()
+
+
+def attach_to_bot(scheduler: RequestScheduler, bot: Any) -> DiscordHTTPAdapter:
+    adapter = DiscordHTTPAdapter(scheduler)
+    adapter.attach(bot)
+    return adapter

{requestflow-0.1.0 → requestflow-0.1.1}/src/requestflow/models.py

@@ -1,7 +1,7 @@
 import asyncio
 import time
 from dataclasses import dataclass, field
-from typing import Any, Callable, Coroutine, Dict, Generic, Optional, TypeVar
+from typing import Any, Callable, Coroutine, Dict, Generic, Optional, TypeVar, Union
 from requestflow.priorities import Priority
 T = TypeVar('t')
 
@@ -14,7 +14,7 @@ class RequestItem(Generic[T]):
     kwargs: dict = field(default_factory=dict)
     priority: Priority = Priority.NORMAL
     effective_priority: Priority = Priority.NORMAL
-    guild_id: Optional[int] = None
+    guild_id: Optional[Union[int, str]] = None
     route_key: Optional[str] = None
     is_interaction: bool = False
     dedup_key: Optional[str] = None

{requestflow-0.1.0 → requestflow-0.1.1}/src/requestflow/queue.py

@@ -1,7 +1,7 @@
 import asyncio
 import collections
 import time
-from typing import Callable, Deque, Dict, List, Optional, Set
+from typing import Callable, Deque, Dict, List, Optional, Set, Union
 from requestflow.exceptions import QueueFullError
 from requestflow.models import RequestItem
 from requestflow.policies import OverloadPolicy
@@ -19,12 +19,12 @@ class RequestQueue:
         self._size: int = 0
         self._sequence_counter: int = 0
         self._high_water_mark: int = 0
-        self._queues: Dict[Priority, Dict[Optional[int], Deque[RequestItem]]] = {
+        self._queues: Dict[Priority, Dict[Optional[Union[int, str]], Deque[RequestItem]]] = {
             p: collections.defaultdict(collections.deque) for p in Priority}
-        self._active_guild_keys: Dict[Priority, List[Optional[int]]] = {
+        self._active_guild_keys: Dict[Priority, List[Optional[Union[int, str]]]] = {
             p: [] for p in Priority}
         self._guild_indices: Dict[Priority, int] = {p: 0 for p in Priority}
-        self._guild_deficits: Dict[Optional[int],
+        self._guild_deficits: Dict[Optional[Union[int, str]],
                                    int] = collections.defaultdict(int)
         self._not_empty: asyncio.Event = asyncio.Event()
         self._not_full: asyncio.Event = asyncio.Event()
@@ -61,7 +61,7 @@ class RequestQueue:
         return counts
 
     def get_active_guild_count(self) -> int:
-        seen: Set[Optional[int]] = set()
+        seen: Set[Optional[Union[int, str]]] = set()
         for p in Priority:
             for guild_id, q in self._queues[p].items():
                 if len(q) > 0:
@@ -120,7 +120,7 @@ class RequestQueue:
         for p in reversed(Priority):
             guild_dict = self._queues[p]
             oldest_item: Optional[RequestItem] = None
-            target_guild: Optional[int] = None
+            target_guild: Optional[Union[int, str]] = None
             for g, q in guild_dict.items():
                 if q:
                     head = q[0]

{requestflow-0.1.0 → requestflow-0.1.1}/src/requestflow/ratelimit.py

@@ -36,6 +36,10 @@ class GlobalRateLimiter:
     def ceiling(self) -> float:
         return self._ceiling
 
+    @property
+    def burst_allowance(self) -> float:
+        return self._burst_tokens
+
     @property
     def is_cooling_down(self) -> bool:
         return time.monotonic() < self._global_cooldown_until
@@ -73,11 +77,13 @@ class GlobalRateLimiter:
                     continue
             async with self._lock:
                 now = time.monotonic()
-                if now > self._tat:
-                    self._tat = now
-                dispatch_time = self._tat
-                self._tat = dispatch_time + self._emission_interval
-                delay = max(0.0, dispatch_time - now)
+                tat = max(now, self._tat)
+                if tat - now <= self._tau + 1e-9:
+                    delay = 0.0
+                    self._tat = tat + self._emission_interval
+                else:
+                    delay = max(0.0, (tat - self._tau) - now)
+                    self._tat = tat + self._emission_interval
             if delay > 0:
                 try:
                     await asyncio.sleep(delay)

{requestflow-0.1.0 → requestflow-0.1.1}/src/requestflow/scheduler.py

@@ -1,6 +1,6 @@
 import asyncio
 import time
-from typing import Any, Callable, Coroutine, List, Optional, Set, TypeVar
+from typing import Any, Callable, Coroutine, List, Optional, Set, TypeVar, Union
 from requestflow.exceptions import OperationCancelledError, QueueFullError, SchedulerClosedError, SchedulerNotStartedError
 from requestflow.executor import RequestExecutor
 from requestflow.metrics import RequestMetrics
@@ -79,7 +79,7 @@ class RequestScheduler:
             except Exception:
                 break
 
-    async def submit(self, operation: Callable[..., Coroutine[Any, Any, T]], *args: Any, priority: Priority = Priority.NORMAL, guild_id: Optional[int] = None, route_key: Optional[str] = None, is_interaction: bool = False, dedup_key: Optional[str] = None, timeout: Optional[float] = None, enqueue_timeout: Optional[float] = None, **kwargs: Any) -> T:
+    async def submit(self, operation: Callable[..., Coroutine[Any, Any, T]], *args: Any, priority: Priority = Priority.NORMAL, guild_id: Optional[Union[int, str]] = None, route_key: Optional[str] = None, is_interaction: bool = False, dedup_key: Optional[str] = None, timeout: Optional[float] = None, enqueue_timeout: Optional[float] = None, **kwargs: Any) -> T:
         if not self._is_started:
             raise SchedulerNotStartedError(
                 "scheduler has not been started. call 'await flow.start()'.")

{requestflow-0.1.0 → requestflow-0.1.1/src/requestflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: requestflow
-Version: 0.1.0
+Version: 0.1.1
 Summary: stop getting 429 ratelimited like an amateur. high-performance http scheduling and pacing for discord.py.
 Author: requestflow
 License-Expression: MIT

{requestflow-0.1.0 → requestflow-0.1.1}/tests/test_discord_integration.py

@@ -1,66 +1,98 @@
-import asyncio
-from unittest.mock import AsyncMock, MagicMock
-import pytest
-import discord
-from discord.http import Route
-from requestflow.flow import RequestFlow
-from requestflow.integrations.discord_py import DiscordHTTPAdapter, attach_to_bot
-from requestflow.priorities import Priority
-
-
-class MockHTTPClient:
-    def __init__(self):
-        self.request = AsyncMock()
-
-
-class MockBot:
-    def __init__(self):
-        self.http = MockHTTPClient()
-
-
-def test_compatibility_check():
-    DiscordHTTPAdapter.verify_compatibility()
-
-
-@pytest.mark.asyncio
-async def test_transparent_adapter_mode_b():
-    async with RequestFlow() as flow:
-        bot = MockBot()
-        original_request = bot.http.request
-        original_request.return_value = {'id': '12345', 'content': 'hello'}
-        flow.attach(bot)
-        assert bot.http.request != original_request
-        route = Route(
-            'POST', '/channels/{channel_id}/messages', channel_id=98765)
-        result = await bot.http.request(route, json={'content': 'hello'})
-        assert result == {'id': '12345', 'content': 'hello'}
-        original_request.assert_called_once()
-        assert flow.stats.submitted == 1
-        assert flow.stats.completed == 1
-        flow.detach(bot)
-        assert bot.http.request == original_request
-
-
-@pytest.mark.asyncio
-async def test_interaction_endpoint_critical_priority():
-    async with RequestFlow() as flow:
-        bot = MockBot()
-        bot.http.request.return_value = {'type': 4}
-        flow.attach(bot)
-        route = Route(
-            'POST', '/interactions/{interaction_id}/{interaction_token}/callback', interaction_id=111, interaction_token='xyz')
-        res = await bot.http.request(route, json={'type': 4})
-        assert res == {'type': 4}
-        assert flow.stats.submitted == 1
-        assert flow.stats.completed == 1
-
-
-@pytest.mark.asyncio
-async def test_managed_mode_a_with_discord_call():
-    async with RequestFlow() as flow:
-        mock_send = AsyncMock(
-            return_value={'id': 1, 'content': 'managed message'})
-        res = await flow.submit(mock_send, content='managed message', priority=Priority.HIGH, guild_id=123456)
-        assert res == {'id': 1, 'content': 'managed message'}
-        mock_send.assert_called_once_with(content='managed message')
-        assert flow.stats.completed == 1
+import asyncio
+from unittest.mock import AsyncMock, MagicMock
+import pytest
+import discord
+from discord.http import Route
+from requestflow.flow import RequestFlow
+from requestflow.integrations.discord_py import DiscordHTTPAdapter, attach_to_bot, extract_resource_id
+from requestflow.priorities import Priority
+
+
+class MockHTTPClient:
+    def __init__(self):
+        self.request = AsyncMock()
+
+
+class MockBot:
+    def __init__(self):
+        self.http = MockHTTPClient()
+
+
+def test_compatibility_check():
+    DiscordHTTPAdapter.verify_compatibility()
+
+
+def test_resource_id_extraction():
+    route_guild = Route('GET', '/guilds/{guild_id}/members', guild_id=123)
+    assert extract_resource_id(route_guild) == 123
+
+    route_channel = Route('POST', '/channels/{channel_id}/messages', channel_id=456)
+    assert extract_resource_id(route_channel) == 456
+
+    route_webhook = Route('POST', '/webhooks/{webhook_id}/{webhook_token}', webhook_id=789, webhook_token='tok')
+    assert extract_resource_id(route_webhook) == 789
+
+    mock_channel = MagicMock()
+    mock_channel.guild.id = 999
+    mock_bot = MagicMock()
+    mock_bot.get_channel.return_value = mock_channel
+    assert extract_resource_id(route_channel, mock_bot) == 999
+
+
+@pytest.mark.asyncio
+async def test_transparent_adapter_mode_b():
+    async with RequestFlow() as flow:
+        bot = MockBot()
+        original_request = bot.http.request
+        original_request.return_value = {'id': '12345', 'content': 'hello'}
+        flow.attach(bot)
+        assert bot.http.request != original_request
+        route = Route(
+            'POST', '/channels/{channel_id}/messages', channel_id=98765)
+        result = await bot.http.request(route, json={'content': 'hello'})
+        assert result == {'id': '12345', 'content': 'hello'}
+        original_request.assert_called_once()
+        assert flow.stats.submitted == 1
+        assert flow.stats.completed == 1
+        flow.detach(bot)
+        assert bot.http.request == original_request
+
+
+@pytest.mark.asyncio
+async def test_automatic_cross_guild_fairness_partitioning():
+    async with RequestFlow() as flow:
+        bot = MockBot()
+        bot.http.request.return_value = {'status': 'ok'}
+        flow.attach(bot)
+        route_a = Route('POST', '/channels/{channel_id}/messages', channel_id=1001)
+        route_b = Route('POST', '/channels/{channel_id}/messages', channel_id=2002)
+        t1 = asyncio.create_task(bot.http.request(route_a))
+        t2 = asyncio.create_task(bot.http.request(route_b))
+        await asyncio.gather(t1, t2)
+        assert flow.stats.submitted == 2
+        assert flow.stats.completed == 2
+
+
+@pytest.mark.asyncio
+async def test_interaction_endpoint_critical_priority():
+    async with RequestFlow() as flow:
+        bot = MockBot()
+        bot.http.request.return_value = {'type': 4}
+        flow.attach(bot)
+        route = Route(
+            'POST', '/interactions/{interaction_id}/{interaction_token}/callback', interaction_id=111, interaction_token='xyz')
+        res = await bot.http.request(route, json={'type': 4})
+        assert res == {'type': 4}
+        assert flow.stats.submitted == 1
+        assert flow.stats.completed == 1
+
+
+@pytest.mark.asyncio
+async def test_managed_mode_a_with_discord_call():
+    async with RequestFlow() as flow:
+        mock_send = AsyncMock(
+            return_value={'id': 1, 'content': 'managed message'})
+        res = await flow.submit(mock_send, content='managed message', priority=Priority.HIGH, guild_id=123456)
+        assert res == {'id': 1, 'content': 'managed message'}
+        mock_send.assert_called_once_with(content='managed message')
+        assert flow.stats.completed == 1

{requestflow-0.1.0 → requestflow-0.1.1}/tests/test_ratelimit.py

@@ -1,89 +1,103 @@
-import asyncio
-import time
-import pytest
-from requestflow.ratelimit import GlobalRateLimiter, RateLimitCoordinator, RouteBucketCoordinator
-
-
-@pytest.mark.asyncio
-async def test_global_rate_limiter_validation():
-    with pytest.raises(ValueError):
-        GlobalRateLimiter(rate=0)
-    with pytest.raises(ValueError):
-        GlobalRateLimiter(rate=-10)
-    with pytest.raises(ValueError):
-        GlobalRateLimiter(rate=60.0, ceiling=50.0, allow_custom_ceiling=False)
-    limiter = GlobalRateLimiter(
-        rate=100.0, ceiling=50.0, allow_custom_ceiling=True)
-    assert limiter.rate == 100.0
-
-
-@pytest.mark.asyncio
-async def test_interaction_bypass_pacing():
-    limiter = GlobalRateLimiter(rate=5.0, burst_allowance=1.0)
-    t0 = time.monotonic()
-    for _ in range(5):
-        delay = await limiter.acquire(is_interaction=True)
-        assert delay == 0.0
-    elapsed = time.monotonic() - t0
-    assert elapsed < 0.05
-
-
-@pytest.mark.asyncio
-async def test_route_cooldown_independence():
-    route_coord = RouteBucketCoordinator()
-    route_a = 'POST /channels/1/messages'
-    route_b = 'POST /channels/2/messages'
-    route_coord.update_route_cooldown(route_a, retry_after=1.0)
-    assert route_coord.is_route_cooling_down(route_a) is True
-    assert route_coord.is_route_cooling_down(route_b) is False
-    assert route_coord.get_route_delay(route_b) == 0.0
-    assert route_coord.get_route_delay(route_a) > 0.0
-
-
-@pytest.mark.asyncio
-async def test_route_header_update():
-    route_coord = RouteBucketCoordinator()
-    route = 'GET /guilds/123/members'
-    route_coord.update_from_headers(
-        route, {'X-RateLimit-Remaining': '0', 'X-RateLimit-Reset-After': '0.5'})
-    assert route_coord.is_route_cooling_down(route) is True
-    assert route_coord.get_route_delay(route) > 0.0
-
-
-@pytest.mark.asyncio
-async def test_global_429_cooldown():
-    limiter = GlobalRateLimiter(rate=40.0)
-    limiter.handle_global_429(retry_after=0.1)
-    assert limiter.is_cooling_down is True
-    t0 = time.monotonic()
-    await limiter.acquire()
-    elapsed = time.monotonic() - t0
-    assert elapsed >= 0.08
-    assert limiter.is_cooling_down is False
-
-
-@pytest.mark.asyncio
-async def test_dynamic_rate_update():
-    limiter = GlobalRateLimiter(rate=20.0, ceiling=50.0)
-    assert limiter.rate == 20.0
-    await limiter.update_rate(40.0)
-    assert limiter.rate == 40.0
-    with pytest.raises(ValueError):
-        await limiter.update_rate(60.0)
-
-
-@pytest.mark.asyncio
-async def test_limiter_cancellation_safety():
-    limiter = GlobalRateLimiter(rate=2.0)
-
-    async def acquire_task():
-        await limiter.acquire()
-    await limiter.acquire()
-    task = asyncio.create_task(acquire_task())
-    await asyncio.sleep(0.01)
-    task.cancel()
-    with pytest.raises(asyncio.CancelledError):
-        await task
-    t0 = time.monotonic()
-    await limiter.acquire()
-    assert time.monotonic() - t0 < 0.6
+import asyncio
+import time
+import pytest
+from requestflow.ratelimit import GlobalRateLimiter, RateLimitCoordinator, RouteBucketCoordinator
+
+
+@pytest.mark.asyncio
+async def test_global_rate_limiter_validation():
+    with pytest.raises(ValueError):
+        GlobalRateLimiter(rate=0)
+    with pytest.raises(ValueError):
+        GlobalRateLimiter(rate=-10)
+    with pytest.raises(ValueError):
+        GlobalRateLimiter(rate=60.0, ceiling=50.0, allow_custom_ceiling=False)
+    limiter = GlobalRateLimiter(
+        rate=100.0, ceiling=50.0, allow_custom_ceiling=True)
+    assert limiter.rate == 100.0
+
+
+@pytest.mark.asyncio
+async def test_interaction_bypass_pacing():
+    limiter = GlobalRateLimiter(rate=5.0, burst_allowance=1.0)
+    t0 = time.monotonic()
+    for _ in range(5):
+        delay = await limiter.acquire(is_interaction=True)
+        assert delay == 0.0
+    elapsed = time.monotonic() - t0
+    assert elapsed < 0.05
+
+
+@pytest.mark.asyncio
+async def test_gcra_burst_tolerance():
+    limiter = GlobalRateLimiter(rate=20.0, burst_allowance=3.0)
+    delays = []
+    for _ in range(4):
+        delays.append(await limiter.acquire())
+    assert delays == [0.0, 0.0, 0.0, 0.0]
+    t0 = time.monotonic()
+    d = await limiter.acquire()
+    elapsed = time.monotonic() - t0
+    assert d > 0.0
+    assert elapsed >= 0.03
+
+
+@pytest.mark.asyncio
+async def test_route_cooldown_independence():
+    route_coord = RouteBucketCoordinator()
+    route_a = 'POST /channels/1/messages'
+    route_b = 'POST /channels/2/messages'
+    route_coord.update_route_cooldown(route_a, retry_after=1.0)
+    assert route_coord.is_route_cooling_down(route_a) is True
+    assert route_coord.is_route_cooling_down(route_b) is False
+    assert route_coord.get_route_delay(route_b) == 0.0
+    assert route_coord.get_route_delay(route_a) > 0.0
+
+
+@pytest.mark.asyncio
+async def test_route_header_update():
+    route_coord = RouteBucketCoordinator()
+    route = 'GET /guilds/123/members'
+    route_coord.update_from_headers(
+        route, {'X-RateLimit-Remaining': '0', 'X-RateLimit-Reset-After': '0.5'})
+    assert route_coord.is_route_cooling_down(route) is True
+    assert route_coord.get_route_delay(route) > 0.0
+
+
+@pytest.mark.asyncio
+async def test_global_429_cooldown():
+    limiter = GlobalRateLimiter(rate=40.0)
+    limiter.handle_global_429(retry_after=0.1)
+    assert limiter.is_cooling_down is True
+    t0 = time.monotonic()
+    await limiter.acquire()
+    elapsed = time.monotonic() - t0
+    assert elapsed >= 0.08
+    assert limiter.is_cooling_down is False
+
+
+@pytest.mark.asyncio
+async def test_dynamic_rate_update():
+    limiter = GlobalRateLimiter(rate=20.0, ceiling=50.0)
+    assert limiter.rate == 20.0
+    await limiter.update_rate(40.0)
+    assert limiter.rate == 40.0
+    with pytest.raises(ValueError):
+        await limiter.update_rate(60.0)
+
+
+@pytest.mark.asyncio
+async def test_limiter_cancellation_safety():
+    limiter = GlobalRateLimiter(rate=2.0, burst_allowance=0.0)
+
+    async def acquire_task():
+        await limiter.acquire()
+    await limiter.acquire()
+    task = asyncio.create_task(acquire_task())
+    await asyncio.sleep(0.01)
+    task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await task
+    t0 = time.monotonic()
+    await limiter.acquire()
+    assert time.monotonic() - t0 < 0.6