From 146ebe5094bd0422598b3a2f943d1d06322d2f80 Mon Sep 17 00:00:00 2001 From: Deepanshu Date: Sat, 5 Sep 2026 07:22:04 -0400 Subject: [PATCH] refactor: trim excessive source comments in tag rate limit types Greptile flagged the new TagRateLimitEntry/TagRateLimitScope docstrings and the InMemoryCache ttl forwarding comment as excessive per the repo's source-comment rule. Condensed each to one concise line while keeping the non-obvious behavior they document. --- litellm/caching/in_memory_cache.py | 7 +- litellm/types/router.py | 78 ++----------------- ui/litellm-dashboard/src/lib/http/schema.d.ts | 6 +- 3 files changed, 10 insertions(+), 81 deletions(-) diff --git a/litellm/caching/in_memory_cache.py b/litellm/caching/in_memory_cache.py index 7edf4672963..58a0c14fbeb 100644 --- a/litellm/caching/in_memory_cache.py +++ b/litellm/caching/in_memory_cache.py @@ -248,12 +248,7 @@ class InMemoryCache(BaseCache): ) -> list[float] | None: results: Final = [] for increment in increment_list: - # Each operation's own ttl must reach set_cache, or a key with no - # live ttl yet falls through to the cache's short default_ttl - # instead of the caller's real (often much longer) window -- - # allow_ttl_override already leaves an existing, still-live ttl - # untouched on a later increment, so passing this through on - # every call is safe: it only ever takes effect the first time. + # forward each op's own ttl; allow_ttl_override leaves an already-live ttl untouched result = await self.async_increment( increment["key"], increment["increment_value"], ttl=increment.get("ttl"), **kwargs ) diff --git a/litellm/types/router.py b/litellm/types/router.py index 3cdcbaa8a4f..6da67a2c3d8 100644 --- a/litellm/types/router.py +++ b/litellm/types/router.py @@ -162,13 +162,7 @@ def _as_utc(value: datetime.datetime | None) -> datetime.datetime | None: class TagRateLimitScope(BaseModel): - """ - A gate on a tag OTHER than the entry's own `tag_id` -- e.g. scoping an - entry to `tag_id: company_id, values: ["1032"]` so it only applies to - requests tagged as belonging to company 1032, independent of whichever - tag the entry itself keys its bucket by. See `TagRateLimitEntry.enabled_for`/ - `disabled_for`, which are the only two fields that construct this. - """ + """A gate on a tag other than the entry's own `tag_id`, used by `TagRateLimitEntry.enabled_for`/`disabled_for`.""" tag_id: str values: tuple[str, ...] @@ -183,17 +177,7 @@ class TagRateLimitScope(BaseModel): @model_validator(mode="after") def _normalize_values(self) -> "TagRateLimitScope": - # Sorted and deduplicated: `values` is only ever used for membership - # tests (see _entry_applies), never order-dependent, but is also - # folded verbatim into the dedup signature two deployments' entries - # are compared by (see _scope_signature) -- an unsorted tuple would - # make config-order alone, not policy, decide whether two entries - # dedup to one shared bucket or wrongly split into two. - # object.__setattr__ bypasses this frozen model's own assignment - # guard -- returning a replacement instance from an "after" validator - # is silently ignored when constructing via __init__ (only takes - # effect via model_validate), so mutating in place is the only way - # this normalization reliably applies regardless of construction path. + # sorted+deduped so dedup-signature comparisons aren't order-sensitive; __setattr__ works around frozen=True object.__setattr__(self, "values", tuple(sorted(set(self.values)))) # mutable-ok: frozen before escaping return self @@ -204,66 +188,25 @@ class TagRateLimitEntry(BaseModel): limit: float period_seconds: int scope_by_key_hash: bool = False - # Overrides this entry's bucket/reservation key TTL (Redis, and the - # in-memory fallback when Redis isn't configured). Defaults to - # period_seconds + 3600 when unset -- see _PROXY_ModelBasedTagRateLimitsHook._ttl_for. - # A high-cardinality tag_id can keep many keys alive at once; lowering - # this lets an operator shed them sooner without shortening - # period_seconds itself. + # overrides the default bucket ttl (period_seconds + 3600); see _PROXY_ModelBasedTagRateLimitsHook._ttl_for key_ttl_seconds: int | None = None - # Overrides the size of the dedicated in-memory cache partition this - # entry's own keys live in, when Redis isn't configured (or as a local - # fast-path cache when it is). Unset means this entry shares the hook's - # single default partition, sized by - # litellm.model_based_tag_rate_limits_max_in_memory_cache_size (200 if that's also - # unset). A high-cardinality tag_id can churn past that shared cap and - # evict another entry's active counters; setting this gives the entry - # its own dedicated partition instead. + # overrides the shared litellm.model_based_tag_rate_limits_max_in_memory_cache_size (200) with a dedicated partition max_in_memory_cache_size: int | None = None - # Gate this entry on a tag -- often a SECOND, independent tag (e.g. - # `enabled_for: {tag_id: company_id, values: ["1032"]}` to scope an - # override to one company's traffic), but `tag_id` can equally be set to - # this same entry's own `tag_id` to scope by a subset of its own - # resolved identity instead, without a second tag at all. - # `disabled_for` is checked first (deny overrides allow) when both are - # set. An absent gate tag never satisfies `enabled_for` (an allowlist - # gate requires an explicit match) but never triggers `disabled_for` - # either (nothing to match against a denylist). + # gate this entry on another tag; disabled_for wins over enabled_for; an absent tag never matches either allowlist enabled_for: TagRateLimitScope | None = None disabled_for: TagRateLimitScope | None = None - # Restrict this entry to requests authenticated with one of these virtual - # keys' own `key_alias`. Unset (the default) means the entry applies to - # every request regardless of which key made it. A key with no alias set - # never satisfies this allowlist, same "absent gate never matches an - # allowlist" precedent as `enabled_for`. apply_to_key_alias: tuple[str, ...] | None = None - # Restrict this entry to requests whose caller-facing `model` matches one - # of these names. Unset (the default) means the entry applies to every - # model. A request with no `model` field never satisfies this allowlist, - # same "absent gate never matches an allowlist" precedent as - # `apply_to_key_alias`. apply_to_models: tuple[str, ...] | None = None model_config = ConfigDict(protected_namespaces=()) @model_validator(mode="after") def _validate_limit(self) -> "TagRateLimitEntry": - # NaN compares False against every ordering operator, so a NaN limit - # makes the atomic requests/concurrency check-and-increment (which - # rejects when the new value exceeds the limit) never reject -- - # admitting indefinitely -- while the read-only tokens/dollars check - # (which admits when the current value is under the limit) never - # admits, rejecting every tagged request. Either outcome silently - # defeats the entry; reject it at config load time instead. + # NaN compares False against every ordering operator, silently defeating whichever check gates this limit if math.isnan(self.limit): raise ValueError("limit must not be NaN") - # Positive infinity never rejects the checks that gate this limit; negative - # infinity always does. Both silently defeat the entry. if math.isinf(self.limit): raise ValueError("limit must be finite") - # Zero or negative makes every check that gates this limit either always - # reject or never admit, silently blocking or admitting all matching traffic - # instead of the likely intended config. if self.limit <= 0: raise ValueError("limit must be a positive number") return self @@ -278,8 +221,7 @@ class TagRateLimitEntry(BaseModel): def _validate_key_ttl_seconds(self) -> "TagRateLimitEntry": if self.key_ttl_seconds is not None and self.key_ttl_seconds <= 0: raise ValueError("key_ttl_seconds must be a positive integer when set") - # A shorter TTL than period_seconds expires the counter before its period - # elapses, letting it reset early and exceed the limit. + # a shorter ttl than period_seconds resets the counter early, letting it exceed the limit if self.key_ttl_seconds is not None and self.key_ttl_seconds < self.period_seconds: raise ValueError("key_ttl_seconds must be at least period_seconds when set") return self @@ -298,11 +240,7 @@ class TagRateLimitEntry(BaseModel): @model_validator(mode="after") def _normalize_apply_to_key_alias(self) -> "TagRateLimitEntry": - # Sorted and deduplicated for the same reason as - # TagRateLimitScope._normalize_values: only ever used for membership - # tests, but also folded verbatim into the dedup signature, where an - # unsorted tuple would make config-order alone decide whether two - # deployments' entries dedup to one shared bucket. + # same reason as TagRateLimitScope._normalize_values if self.apply_to_key_alias is not None: self.apply_to_key_alias = tuple(sorted(set(self.apply_to_key_alias))) # mutable-ok: frozen before escaping return self diff --git a/ui/litellm-dashboard/src/lib/http/schema.d.ts b/ui/litellm-dashboard/src/lib/http/schema.d.ts index 0c21fb78cce..94b37901fc7 100644 --- a/ui/litellm-dashboard/src/lib/http/schema.d.ts +++ b/ui/litellm-dashboard/src/lib/http/schema.d.ts @@ -36710,11 +36710,7 @@ export interface components { }; /** * TagRateLimitScope - * @description A gate on a tag OTHER than the entry's own `tag_id` -- e.g. scoping an - * entry to `tag_id: company_id, values: ["1032"]` so it only applies to - * requests tagged as belonging to company 1032, independent of whichever - * tag the entry itself keys its bucket by. See `TagRateLimitEntry.enabled_for`/ - * `disabled_for`, which are the only two fields that construct this. + * @description A gate on a tag other than the entry's own `tag_id`, used by `TagRateLimitEntry.enabled_for`/`disabled_for`. */ TagRateLimitScope: { /** Tag Id */