refactor(proxy): simplify team member budget backfill

This commit is contained in:
shrey kharbanda 2026-10-24 11:22:03 -07:00
parent d06ee225a1
commit edd697564b
11 changed files with 1183 additions and 912 deletions

View file

@ -128,7 +128,6 @@ from litellm.proxy.common_utils.user_api_key_cache import (
project_spend_counter_key,
tag_cache_key,
tag_registry_cache_key,
team_member_default_budget_cache_key,
team_membership_auth_cache_key,
team_membership_reservation_cache_key,
)
@ -1767,7 +1766,7 @@ async def get_team_member_default_budget(
if prisma_client is None:
return None
cache_key: Final = team_member_default_budget_cache_key(budget_id)
cache_key: Final = f"team_member_default_budget:{budget_id}"
cached_budget: Final = await user_api_key_cache.async_get_cache(
key=cache_key,

View file

@ -392,10 +392,6 @@ def team_membership_reservation_cache_key(user_id: str, team_id: str) -> str:
return f"team_membership:{user_id}:{team_id}"
def team_member_default_budget_cache_key(budget_id: str) -> str:
return f"team_member_default_budget:{budget_id}"
#: Cached under ``team_membership_reservation_cache_key`` when a member has no ``LiteLLM_TeamMembership``
#: row, so a session-token member without a per-member budget costs no DB read per request. Lives beside
#: the key builder because it is part of the same cache protocol: every reader of the key must know that

View file

@ -20,11 +20,10 @@ from typing import Final
from fastapi import APIRouter, Depends, HTTPException
from litellm._internal_context import service_target
from litellm._logging import verbose_proxy_logger
from litellm.proxy._types import *
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
from litellm.proxy.common_utils.auth_cache_invalidation_pubsub import evict_and_broadcast
from litellm.proxy.common_utils.timezone_utils import get_budget_reset_time
from litellm.proxy.common_utils.user_api_key_cache import team_member_default_budget_cache_key
from litellm.proxy.management_endpoints.common_utils import ( # noqa: F401 # legacy module exports
_user_has_admin_view, # pyright: ignore[reportPrivateUsage,reportUnusedImport] # backwards-compatible package export
user_api_key_has_admin_view,
@ -203,10 +202,10 @@ async def update_budget(
data=budget_obj_jsonified,
)
with service_target("team_member_budgets"):
await evict_and_broadcast(
cache_keys=(team_member_default_budget_cache_key(budget_obj.budget_id),),
user_api_key_cache=user_api_key_cache,
)
try:
await user_api_key_cache.async_delete_cache(key=f"team_member_default_budget:{budget_obj.budget_id}")
except Exception: # noqa: BLE001 # Cache failure must not fail a committed budget update.
verbose_proxy_logger.warning("Failed to evict the team member default budget cache", exc_info=True)
return response

View file

@ -619,7 +619,7 @@ def _is_set_budget_value(value: object) -> bool:
return True
def has_meaningful_budget_limit(budget_values: Mapping[str, object]) -> bool:
def _has_meaningful_budget_limit(budget_values: Mapping[str, object]) -> bool:
"""A budget is meaningful if at least one limit is actually set; an empty
list (no model restriction) and None both count as unset."""
return any(_is_set_budget_value(budget_values.get(field)) for field in _TEAM_MEMBER_BUDGET_LIMIT_FIELDS)
@ -704,7 +704,7 @@ async def upsert_budget_and_membership(
existing_budget: Final = await tx.litellm_budgettable.find_unique(where={"budget_id": existing_budget_id})
merged: Final = existing_budget.model_dump() if existing_budget is not None else {}
merged.update(write_data)
if not has_meaningful_budget_limit(merged):
if not _has_meaningful_budget_limit(merged):
await _fall_back_to_team_default()
return
await tx.litellm_budgettable.update(
@ -746,7 +746,7 @@ async def upsert_budget_and_membership(
if create_data.get("budget_reset_at") is None:
create_data.pop("budget_reset_at", None)
if not has_meaningful_budget_limit(create_data):
if not _has_meaningful_budget_limit(create_data):
if existing_budget_id is not None and not temp_only:
await _fall_back_to_team_default()
return

View file

@ -133,7 +133,6 @@ from litellm.proxy.common_utils.callback_utils import encrypt_callback_vars
from litellm.proxy.common_utils.json_merge_patch import apply_json_merge_patch
from litellm.proxy.common_utils.user_api_key_cache import (
UserApiKeyCache,
team_member_default_budget_cache_key,
team_membership_auth_cache_key,
team_membership_reservation_cache_key,
)
@ -207,7 +206,6 @@ from litellm.proxy.management_helpers.object_permission_utils import ( # noqa:
from litellm.proxy.management_helpers.ptu_share_guard import raise_if_teams_hold_ptu_shares
from litellm.proxy.management_helpers.team_member_default_budget import (
MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE,
MovedMemberBudgets,
TeamMemberDefaultBudgetWrite,
TooManyMemberBudgetsToMove,
move_member_budgets_to_default,
@ -660,7 +658,7 @@ class TeamMemberBudgetHandler:
) -> None:
if user_api_key_cache is not None:
await evict_and_broadcast(
cache_keys=(team_member_default_budget_cache_key(budget_id),), user_api_key_cache=user_api_key_cache
cache_keys=(f"team_member_default_budget:{budget_id}",), user_api_key_cache=user_api_key_cache
)
@staticmethod
@ -1246,20 +1244,8 @@ async def _write_team_update(
@dataclass(frozen=True, slots=True)
class _TeamWrite:
team_row: "prisma_models.LiteLLM_TeamTable | None"
roster_user_ids: tuple[str, ...]
moved_member_budgets: MovedMemberBudgets | None
def backfill_response(self) -> Mapping[str, TeamMemberBudgetBackfillResult]:
if self.moved_member_budgets is None:
return MappingProxyType({})
return MappingProxyType({"team_member_budget_backfill_result": self.moved_member_budgets.result()})
def backfill_audit(self) -> Mapping[str, object]:
return MappingProxyType({key: result.model_dump() for key, result in self.backfill_response().items()})
def changed_member_user_ids(self) -> tuple[str, ...]:
moved: Final = () if self.moved_member_budgets is None else self.moved_member_budgets.user_ids
return tuple(dict.fromkeys((*self.roster_user_ids, *moved)))
changed_member_user_ids: tuple[str, ...]
backfill_result: TeamMemberBudgetBackfillResult | None
async def _write_team_with_member_default_budget(
@ -1270,7 +1256,6 @@ async def _write_team_with_member_default_budget(
max_budget_guard: _MaxBudgetGuard | None,
default_budget_write: TeamMemberDefaultBudgetWrite,
backfill: TeamMemberBudgetBackfill,
user_api_key_dict: UserAPIKeyAuth,
changed_by: str,
) -> _TeamWrite:
"""One transaction under the team lock, so the default, every member it reaches and the team row commit
@ -1291,7 +1276,7 @@ async def _write_team_with_member_default_budget(
team_id=team_id,
default_budget_id=default_budget_write.budget_id,
backfill=backfill,
changed_by=user_api_key_dict,
changed_by=changed_by,
)
if isinstance(moved, TooManyMemberBudgetsToMove):
raise HTTPException(
@ -1308,8 +1293,8 @@ async def _write_team_with_member_default_budget(
team_row: Final = await _write_team_update(_team_tx_db(tx), team_id, team_update_data, max_budget_guard)
return _TeamWrite(
team_row=team_row,
roster_user_ids=member_user_ids,
moved_member_budgets=moved if backfill != "none" else None,
changed_member_user_ids=tuple(dict.fromkeys((*member_user_ids, *moved.user_ids))),
backfill_result=moved.result() if backfill != "none" else None,
)
@ -2606,8 +2591,8 @@ async def update_team(
team_row=await _write_team_update(
_team_db(prisma_client), data.team_id, team_update_data, max_budget_guard
),
roster_user_ids=(),
moved_member_budgets=None,
changed_member_user_ids=(),
backfill_result=None,
)
if default_budget_write is None
else await _write_team_with_member_default_budget(
@ -2617,11 +2602,15 @@ async def update_team(
max_budget_guard=max_budget_guard,
default_budget_write=default_budget_write,
backfill=data.team_member_budget_backfill or "none",
user_api_key_dict=user_api_key_dict,
changed_by=user_api_key_dict.user_id or litellm_proxy_admin_name,
)
)
team_row: Final = team_write.team_row
backfill_response: Final = (
{"team_member_budget_backfill_result": team_write.backfill_result}
if team_write.backfill_result is not None
else {}
)
if team_row is None or team_row.team_id is None:
raise HTTPException(
@ -2636,8 +2625,8 @@ async def update_team(
)
await evict_team_member_cache_keys(
team_id=team_row.team_id,
member_user_ids=team_write.changed_member_user_ids(),
cache_keys=tuple(team_membership_cache_keys(team_row.team_id, team_write.changed_member_user_ids())),
member_user_ids=team_write.changed_member_user_ids,
cache_keys=tuple(team_membership_cache_keys(team_row.team_id, team_write.changed_member_user_ids)),
user_api_key_cache=user_api_key_cache,
)
await sync_team_access_group_membership(prisma_client=prisma_client, team_id=team_row.team_id)
@ -2654,14 +2643,14 @@ async def update_team(
if is_audit_logging_enabled():
await _create_team_update_audit_log(
existing_team_row=existing_team_row,
updated_kv={**updated_kv, **team_write.backfill_audit()},
updated_kv={**updated_kv, **{key: value.model_dump() for key, value in backfill_response.items()}},
team_id=data.team_id,
litellm_changed_by=litellm_changed_by,
user_api_key_dict=user_api_key_dict,
litellm_proxy_admin_name=litellm_proxy_admin_name,
)
return {"team_id": team_row.team_id, "data": team_row, **team_write.backfill_response()}
return {"team_id": team_row.team_id, "data": team_row, **backfill_response}
except Exception as e:
raise handle_exception_on_proxy(e)

View file

@ -1,24 +1,18 @@
import uuid
from collections.abc import Mapping, Sequence
from dataclasses import dataclass
from datetime import datetime
from types import MappingProxyType
from typing import TYPE_CHECKING, Final
from pydantic import BaseModel, ConfigDict, JsonValue, TypeAdapter, field_validator
from pydantic import BaseModel, ConfigDict, JsonValue, TypeAdapter
from litellm.litellm_core_utils.duration_parser import budget_reset_period_key
from litellm.proxy._types import (
TeamMemberBudgetBackfill,
TeamMemberBudgetBackfillResult,
UpdateTeamRequest,
UserAPIKeyAuth,
)
from litellm.proxy.common_utils.timezone_utils import get_budget_reset_time
from litellm.proxy.management_endpoints.common_utils import (
has_meaningful_budget_limit,
upsert_budget_and_membership,
)
if TYPE_CHECKING:
from prisma import Prisma
@ -28,8 +22,6 @@ if TYPE_CHECKING:
MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE: Final = 50_000
_ALWAYS_OWN_LIMITS: Final = frozenset({"allowed_models"})
_DEFAULT_BUDGET_COLUMNS: Final = MappingProxyType(
{
"team_member_budget": "max_budget",
@ -48,23 +40,6 @@ ON CONFLICT (user_id, team_id) DO NOTHING
_LINK_UNBUDGETED_MEMBERSHIPS_SQL: Final = (
'UPDATE "LiteLLM_TeamMembership" SET budget_id = $2 WHERE team_id = $1 AND budget_id IS NULL'
)
_RELINK_TO_DEFAULT_SQL: Final = (
'UPDATE "LiteLLM_TeamMembership" SET budget_id = $2 WHERE team_id = $1 AND user_id = ANY($3::text[])'
)
_CLEAR_MAX_BUDGET_SQL: Final = """
UPDATE "LiteLLM_BudgetTable" SET max_budget = NULL, updated_by = $2, updated_at = (NOW() AT TIME ZONE 'UTC')
WHERE budget_id = ANY($1::text[])
"""
_ALIGN_RESET_TO_DEFAULT_SQL: Final = """
UPDATE "LiteLLM_BudgetTable" b
SET budget_reset_at = (SELECT d.budget_reset_at FROM "LiteLLM_BudgetTable" d WHERE d.budget_id = $2)
FROM "LiteLLM_TeamMembership" m
WHERE m.team_id = $1 AND m.user_id = ANY($3::text[]) AND m.budget_id = b.budget_id AND b.budget_id <> $2
"""
_SHARED_BUDGET_IDS_SQL: Final = """
SELECT budget_id FROM "LiteLLM_TeamMembership" WHERE budget_id = ANY($1::text[])
GROUP BY budget_id HAVING COUNT(*) > 1
"""
_ON_CHOSEN_SIDE_OF_DEFAULT: Final = """m.team_id = $1 AND m.budget_id <> $2 AND CASE $3::text
WHEN 'raise_to_default' THEN b.max_budget < $4::double precision
WHEN 'lower_to_default' THEN b.max_budget > $4::double precision
@ -76,12 +51,40 @@ _CANDIDATES_BY_SCHEDULE_SQL: Final = (
+ _ON_CHOSEN_SIDE_OF_DEFAULT
+ " GROUP BY b.budget_duration"
)
_CANDIDATES_SQL: Final = (
"SELECT m.user_id, b.budget_id, b.soft_budget, b.max_parallel_requests, b.tpm_limit, b.rpm_limit, "
"b.model_max_budget, b.budget_duration, b.allowed_models, b.temp_budget_increase, b.temp_budget_expiry "
'FROM "LiteLLM_TeamMembership" m JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id WHERE '
_MOVE_MEMBERS_SQL: Final = (
"""
WITH candidates AS MATERIALIZED (
SELECT m.user_id, b.*, CASE WHEN
b.soft_budget IS NOT NULL OR b.max_parallel_requests IS NOT NULL OR
b.tpm_limit IS NOT NULL OR b.rpm_limit IS NOT NULL OR b.tpd_limit IS NOT NULL OR
b.temp_budget_increase IS NOT NULL OR b.temp_budget_expiry IS NOT NULL OR
COALESCE(b.model_max_budget, '{}'::jsonb) NOT IN ('{}'::jsonb, 'null'::jsonb) OR
cardinality(b.allowed_models) > 0
THEN gen_random_uuid()::text ELSE $2 END AS next_budget_id
FROM "LiteLLM_TeamMembership" m JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id
WHERE """
+ _ON_CHOSEN_SIDE_OF_DEFAULT
+ " AND (b.budget_duration = ANY($5::text[]) OR ($6::boolean AND b.budget_duration IS NULL))"
+ """ AND (b.budget_duration = ANY($5::text[]) OR ($6::boolean AND b.budget_duration IS NULL))
), copies AS (
INSERT INTO "LiteLLM_BudgetTable" (
budget_id, max_budget, soft_budget, max_parallel_requests, tpm_limit, rpm_limit, tpd_limit,
model_max_budget, budget_duration, budget_reset_at, allowed_models, temp_budget_increase,
temp_budget_expiry, created_by, updated_by, created_at, updated_at
)
SELECT next_budget_id, NULL, soft_budget, max_parallel_requests, tpm_limit, rpm_limit, tpd_limit,
model_max_budget, budget_duration,
(SELECT budget_reset_at FROM "LiteLLM_BudgetTable" WHERE budget_id = $2),
allowed_models, temp_budget_increase, temp_budget_expiry, $7, $7,
NOW() AT TIME ZONE 'UTC', NOW() AT TIME ZONE 'UTC'
FROM candidates WHERE next_budget_id <> $2
RETURNING budget_id
)
UPDATE "LiteLLM_TeamMembership" m SET budget_id = c.next_budget_id
FROM candidates c
WHERE m.team_id = $1 AND m.user_id = c.user_id
AND (c.next_budget_id = $2 OR c.next_budget_id IN (SELECT budget_id FROM copies))
RETURNING m.user_id
"""
)
@ -116,57 +119,15 @@ class _ScheduleCount(BaseModel):
members: int
class _BudgetLimits(BaseModel):
model_config = ConfigDict(frozen=True)
soft_budget: float | None = None
max_parallel_requests: int | None = None
tpm_limit: int | None = None
rpm_limit: int | None = None
model_max_budget: JsonValue = None
budget_duration: str | None = None
allowed_models: tuple[str, ...] | None = None
temp_budget_increase: float | None = None
temp_budget_expiry: datetime | None = None
@field_validator("model_max_budget", mode="before")
@classmethod
def _decode_json_column(cls, value: object) -> object:
return _JSON_VALUE.validate_json(value) if isinstance(value, str) else value
def has_own_limits_beyond(self, default: "_BudgetLimits") -> bool:
own: Final = _JSON_OBJECT.validate_python(self.model_dump(mode="json"))
inherited: Final = _JSON_OBJECT.validate_python(default.model_dump(mode="json"))
return has_meaningful_budget_limit(
{field: value for field, value in own.items() if field in _ALWAYS_OWN_LIMITS or value != inherited[field]}
)
class _MemberBudgetRef(BaseModel):
class _MovedMember(BaseModel):
model_config = ConfigDict(frozen=True)
user_id: str
budget_id: str
@dataclass(frozen=True, slots=True)
class _CustomMemberBudget:
ref: _MemberBudgetRef
keeps_own_limits: bool
class _BudgetIdRow(BaseModel):
model_config = ConfigDict(frozen=True)
budget_id: str
_JSON_VALUE: Final[TypeAdapter[JsonValue]] = TypeAdapter(JsonValue)
_JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue])
_SCHEDULE_COUNTS: Final = TypeAdapter(tuple[_ScheduleCount, ...])
_MEMBER_BUDGET_REFS: Final = TypeAdapter(tuple[_MemberBudgetRef, ...])
_MEMBER_BUDGET_LIMITS: Final = TypeAdapter(tuple[_BudgetLimits, ...])
_BUDGET_IDS: Final = TypeAdapter(tuple[_BudgetIdRow, ...])
_MOVED_MEMBERS: Final = TypeAdapter(tuple[_MovedMember, ...])
def plan_team_member_default_budget_write(
@ -225,11 +186,8 @@ async def move_member_budgets_to_default(
team_id: str,
default_budget_id: str,
backfill: TeamMemberBudgetBackfill,
changed_by: UserAPIKeyAuth,
changed_by: str,
) -> MovedMemberBudgets | TooManyMemberBudgetsToMove:
"""Members compare on their permanent ``max_budget``, and only those resetting on the default's schedule move.
A member whose other limits all match the default is linked to the default row. One holding a limit of its own, or
any model list, keeps its row with ``max_budget`` cleared and its reset moved onto the default's."""
if backfill == "none":
return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0)
default: Final = await _budget_tx_db(tx).find_unique(where={"budget_id": default_budget_id})
@ -246,63 +204,19 @@ async def move_member_budgets_to_default(
return TooManyMemberBudgetsToMove(count=moving)
if moving == 0:
return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=skipped)
rows: Final = await tx.query_raw(
_CANDIDATES_SQL,
team_id,
default_budget_id,
backfill,
default.max_budget,
[count.duration for count in matching if count.duration is not None],
any(count.duration is None for count in matching),
)
default_limits: Final = _BudgetLimits.model_validate(default.model_dump())
candidates: Final = tuple(
_CustomMemberBudget(ref=ref, keeps_own_limits=limits.has_own_limits_beyond(default_limits))
for ref, limits in zip(
_MEMBER_BUDGET_REFS.validate_python(rows), _MEMBER_BUDGET_LIMITS.validate_python(rows), strict=True
moved: Final = _MOVED_MEMBERS.validate_python(
await tx.query_raw(
_MOVE_MEMBERS_SQL,
team_id,
default_budget_id,
backfill,
default.max_budget,
[count.duration for count in matching if count.duration is not None],
any(count.duration is None for count in matching),
changed_by,
)
)
await _move_to_default(tx, candidates, team_id=team_id, default_budget_id=default_budget_id, changed_by=changed_by)
return MovedMemberBudgets(
user_ids=tuple(candidate.ref.user_id for candidate in candidates), skipped_other_reset_period=skipped
)
async def _move_to_default(
tx: "Prisma",
candidates: Sequence[_CustomMemberBudget],
*,
team_id: str,
default_budget_id: str,
changed_by: UserAPIKeyAuth,
) -> None:
keeping: Final = tuple(candidate.ref for candidate in candidates if candidate.keeps_own_limits)
relinking: Final = tuple(candidate.ref.user_id for candidate in candidates if not candidate.keeps_own_limits)
shared: Final = frozenset(
row.budget_id
for row in _BUDGET_IDS.validate_python(
await tx.query_raw(_SHARED_BUDGET_IDS_SQL, list({ref.budget_id for ref in keeping}))
)
)
await tx.execute_raw(_RELINK_TO_DEFAULT_SQL, team_id, default_budget_id, list(relinking))
await tx.execute_raw(
_CLEAR_MAX_BUDGET_SQL,
list({ref.budget_id for ref in keeping if ref.budget_id not in shared}),
changed_by.user_id or "",
)
for ref in keeping:
if ref.budget_id in shared:
await upsert_budget_and_membership(
tx,
team_id=team_id,
user_id=ref.user_id,
existing_budget_id=ref.budget_id,
user_api_key_dict=changed_by,
budget_patch=MappingProxyType({"max_budget": None}),
team_default_budget_id=default_budget_id,
shared_budget_ids=shared,
)
await tx.execute_raw(_ALIGN_RESET_TO_DEFAULT_SQL, team_id, default_budget_id, [ref.user_id for ref in keeping])
return MovedMemberBudgets(user_ids=tuple(member.user_id for member in moved), skipped_other_reset_period=skipped)
def _prisma_columns(columns: Mapping[str, object]) -> Mapping[str, object]:

View file

@ -37,7 +37,6 @@ from litellm.proxy.common_utils.user_api_key_cache import (
project_cache_key,
project_spend_counter_key,
tag_cache_key,
team_member_default_budget_cache_key,
team_membership_reservation_cache_key,
)
from litellm.proxy.spend_tracking.input_tokens import count_input_tokens, count_input_tokens_for_model
@ -745,7 +744,7 @@ async def _get_team_member_budget_counter(
default_budget_id: Final = (team_object.metadata or {}).get("team_member_budget_id")
if isinstance(default_budget_id, str):
default_budget: Final = _CACHED_VALUE.validate_python(
await user_api_key_cache.async_get_cache(key=team_member_default_budget_cache_key(default_budget_id))
await user_api_key_cache.async_get_cache(key=f"team_member_default_budget:{default_budget_id}")
)
default_cap: Final = _to_float(_get_value(default_budget, "max_budget"))
if default_cap is not None and default_cap > 0:

View file

@ -1,12 +1,13 @@
from collections.abc import Mapping
from dataclasses import dataclass
from datetime import datetime, timezone
from typing import Final
import pytest
from prisma import Json
from litellm.proxy.management_helpers.team_member_default_budget import MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE
from tests.integration._support.actors import create_scratch_team
from tests.integration._support.actors import ManagementDatabase, ScratchResources, create_scratch_team
pytestmark = pytest.mark.asyncio(loop_scope="session")
@ -122,7 +123,6 @@ async def test_backfill_moves_only_members_on_the_chosen_side_of_the_new_default
for name, budget in _ROSTER.items():
membership = await _member_budget(db, resources, name)
if name == "own_rpm" and name in moved:
assert membership.budget_id == resources.tag("own-own_rpm")
assert membership.litellm_budget_table.max_budget is None
assert membership.litellm_budget_table.rpm_limit == 5
elif name in moved or budget is None:
@ -214,9 +214,7 @@ async def test_a_moved_member_keeping_their_own_limits_resets_with_the_default(d
async def test_a_member_with_a_model_list_keeps_it_even_when_it_matches_the_default(db, resources):
default_budget_id = await _seed_team(db, resources, {"scoped": _Budget(20.0)})
for budget_id in (default_budget_id, resources.tag("own-scoped")):
await db.db.litellm_budgettable.update(
where={"budget_id": budget_id}, data={"allowed_models": ["gpt-5.4-mini"]}
)
await db.db.litellm_budgettable.update(where={"budget_id": budget_id}, data={"allowed_models": ["test-model"]})
response = _update_team(
db,
@ -226,10 +224,9 @@ async def test_a_member_with_a_model_list_keeps_it_even_when_it_matches_the_defa
assert response.status_code == 200, response.text
scoped = await _member_budget(db, resources, "scoped")
assert scoped.budget_id == resources.tag("own-scoped")
assert (scoped.litellm_budget_table.max_budget, scoped.litellm_budget_table.allowed_models) == (
None,
["gpt-5.4-mini"],
["test-model"],
)
@ -296,3 +293,36 @@ async def test_saving_a_default_links_every_roster_member_without_a_budget_to_it
assert response.status_code == 200, response.text
for name in ("no-row", "no-budget"):
assert (await _member_budget(db, resources, name)).budget_id == default_budget_id, name
@pytest.mark.parametrize(
"limits",
[
{"rpm_limit": 5},
{"tpm_limit": 7},
{"tpd_limit": 11},
{"soft_budget": 0.0},
{"max_parallel_requests": 0},
{"model_max_budget": Json({"test-model": {"max_budget": 2.0}})},
{"allowed_models": ["test-model"]},
{"temp_budget_increase": 5.0, "temp_budget_expiry": datetime(2030, 1, 1, tzinfo=timezone.utc)},
],
)
async def test_moving_a_member_preserves_every_other_limit_even_when_it_matches_the_default(
limits: Mapping[str, object], db: ManagementDatabase, resources: ScratchResources
) -> None:
default_id: Final = await _seed_team(db, resources, {"custom": _Budget(20.0)})
for budget_id in (default_id, resources.tag("own-custom")):
await db.db.litellm_budgettable.update(where={"budget_id": budget_id}, data=dict(limits))
original: Final = (await _member_budget(db, resources, "custom")).litellm_budget_table
response: Final = _update_team(
db, resources.prefix, {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": "raise_to_default"}
)
assert response.status_code == 200, response.text
moved: Final = (await _member_budget(db, resources, "custom")).litellm_budget_table
assert moved.max_budget is None
assert {field: getattr(moved, field) for field in limits} == {field: getattr(original, field) for field in limits}
untouched: Final = await db.db.litellm_budgettable.find_unique(where={"budget_id": original.budget_id})
assert untouched == original

File diff suppressed because it is too large Load diff

View file

@ -44,7 +44,9 @@ async def test_management_otel_span_redacts_mcp_global_env_var_secrets(monkeypat
captured = {}
class _FakeOtelLogger:
async def async_management_endpoint_success_hook(self, logging_payload, parent_otel_span):
async def async_management_endpoint_success_hook(
self, logging_payload, parent_otel_span
):
captured["response"] = logging_payload.response
from litellm.proxy import proxy_server
@ -117,7 +119,9 @@ async def test_management_otel_span_redacts_nested_submission_env_var_secrets(
captured = {}
class _FakeOtelLogger:
async def async_management_endpoint_success_hook(self, logging_payload, parent_otel_span):
async def async_management_endpoint_success_hook(
self, logging_payload, parent_otel_span
):
captured["response"] = logging_payload.response
from litellm.proxy import proxy_server
@ -137,7 +141,9 @@ async def test_management_otel_span_redacts_nested_submission_env_var_secrets(
created_at=datetime.datetime.now(),
updated_at=datetime.datetime.now(),
)
result = MCPSubmissionsSummary(total=1, pending_review=1, active=0, rejected=0, items=[server])
result = MCPSubmissionsSummary(
total=1, pending_review=1, active=0, rejected=0, items=[server]
)
await mgmt_utils._emit_management_endpoint_otel_span(
func=lambda: None,
@ -152,7 +158,11 @@ async def test_management_otel_span_redacts_nested_submission_env_var_secrets(
assert secret not in str(captured["response"])
redacted_item = captured["response"]["items"][0]
redacted_env_vars = redacted_item["env_vars"] if isinstance(redacted_item, dict) else redacted_item.env_vars
redacted_env_vars = (
redacted_item["env_vars"]
if isinstance(redacted_item, dict)
else redacted_item.env_vars
)
assert [entry["value"] for entry in redacted_env_vars] == [""]
assert redacted_env_vars[0]["name"] == "DB_PASSWORD"
# The endpoint's own return value is untouched for the admin UI.
@ -170,7 +180,9 @@ async def test_add_new_member_links_default_team_budget_id():
new_member = Member(user_id=test_user_id, role="user")
user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN)
user_api_key_dict = UserAPIKeyAuth(
user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN
)
mock_prisma_client = AsyncMock()
@ -183,11 +195,15 @@ async def test_add_new_member_links_default_team_budget_id():
"user_role": "internal_user",
}
mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(
return_value=mock_user_response
)
mock_default_budget_row = MagicMock()
mock_default_budget_row.budget_id = test_default_budget_id
mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_default_budget_row)
mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(
return_value=mock_default_budget_row
)
mock_prisma_client.db.litellm_budgettable.create = AsyncMock()
# Mock the team membership creation
@ -198,7 +214,9 @@ async def test_add_new_member_links_default_team_budget_id():
"budget_id": test_default_budget_id,
"litellm_budget_table": None,
}
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response)
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(
return_value=mock_team_membership_response
)
result_user, result_team_membership = await add_new_member(
new_member=new_member,
@ -224,7 +242,9 @@ async def test_add_new_member_links_default_team_budget_id():
)
mock_prisma_client.db.litellm_budgettable.create.assert_not_called()
team_membership_call_args = mock_prisma_client.db.litellm_teammembership.upsert.call_args
team_membership_call_args = (
mock_prisma_client.db.litellm_teammembership.upsert.call_args
)
create_data = team_membership_call_args.kwargs["data"]["create"]
assert create_data["budget_id"] == test_default_budget_id
@ -294,7 +314,9 @@ async def test_add_new_member_no_budget_when_default_budget_row_is_missing():
from litellm.proxy._types import LitellmUserRoles
new_member = Member(user_id="missing-default-user", role="user")
user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN)
user_api_key_dict = UserAPIKeyAuth(
user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN
)
mock_prisma_client = AsyncMock()
mock_user_response = MagicMock()
@ -305,7 +327,9 @@ async def test_add_new_member_no_budget_when_default_budget_row_is_missing():
"user_role": "internal_user",
}
mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(
return_value=mock_user_response
)
mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=None)
mock_prisma_client.db.litellm_budgettable.create = AsyncMock()
mock_membership = MagicMock()
@ -343,7 +367,9 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget():
from litellm.proxy._types import LitellmUserRoles
new_member = Member(user_id="dur-clone-user", role="user")
user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN)
user_api_key_dict = UserAPIKeyAuth(
user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN
)
mock_prisma_client = AsyncMock()
mock_user_response = MagicMock()
@ -354,7 +380,9 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget():
"user_role": "internal_user",
}
mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(
return_value=mock_user_response
)
mock_default_budget_row = MagicMock()
mock_default_budget_row.model_dump.return_value = {
"budget_id": "default-dc",
@ -367,10 +395,14 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget():
"budget_duration": "1d",
"allowed_models": [],
}
mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_default_budget_row)
mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(
return_value=mock_default_budget_row
)
mock_cloned_budget_row = MagicMock()
mock_cloned_budget_row.budget_id = "cloned-dc"
mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_cloned_budget_row)
mock_prisma_client.db.litellm_budgettable.create = AsyncMock(
return_value=mock_cloned_budget_row
)
mock_team_membership_response = MagicMock()
mock_team_membership_response.model_dump.return_value = {
"team_id": "team-dc",
@ -378,7 +410,9 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget():
"budget_id": "cloned-dc",
"litellm_budget_table": None,
}
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response)
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(
return_value=mock_team_membership_response
)
await add_new_member(
new_member=new_member,
@ -392,7 +426,9 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget():
)
mock_prisma_client.db.litellm_budgettable.create.assert_called_once()
cloned_create_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"]
cloned_create_data = (
mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"]
)
assert cloned_create_data["max_budget"] == 100.0 # kept from the team default
assert cloned_create_data["budget_duration"] == "7d" # overridden by the caller
assert cloned_create_data["budget_reset_at"] > datetime.now(timezone.utc)
@ -415,7 +451,9 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget():
new_member = Member(user_id=test_user_id, role="user")
user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN)
user_api_key_dict = UserAPIKeyAuth(
user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN
)
mock_prisma_client = AsyncMock()
@ -427,7 +465,9 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget():
"user_role": "internal_user",
}
mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(
return_value=mock_user_response
)
# Even though we mock these, they must NOT be called on the no-budget path.
mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock()
@ -442,7 +482,9 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget():
"total_spend": 0.0,
"litellm_budget_table": None,
}
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response)
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(
return_value=mock_team_membership_response
)
result_user, result_team_membership = await add_new_member(
new_member=new_member,
@ -466,7 +508,9 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget():
assert result_team_membership.budget_id is None
mock_prisma_client.db.litellm_teammembership.upsert.assert_awaited_once()
upsert_kwargs = mock_prisma_client.db.litellm_teammembership.upsert.call_args.kwargs
assert upsert_kwargs["where"] == {"user_id_team_id": {"user_id": test_user_id, "team_id": test_team_id}}
assert upsert_kwargs["where"] == {
"user_id_team_id": {"user_id": test_user_id, "team_id": test_team_id}
}
assert upsert_kwargs["data"]["create"] == {"user_id": test_user_id, "team_id": test_team_id}
assert "budget_id" not in upsert_kwargs["data"]["update"]
@ -496,7 +540,9 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided():
new_member = Member(user_id=test_user_id, role="user")
# Create UserAPIKeyAuth object
user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN)
user_api_key_dict = UserAPIKeyAuth(
user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN
)
# Mock the prisma client
mock_prisma_client = AsyncMock()
@ -510,12 +556,16 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided():
"user_role": "internal_user",
}
mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(
return_value=mock_user_response
)
# Mock the budget table creation
mock_budget_response = MagicMock()
mock_budget_response.budget_id = test_new_budget_id
mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_budget_response)
mock_prisma_client.db.litellm_budgettable.create = AsyncMock(
return_value=mock_budget_response
)
# Mock the team membership creation
mock_team_membership_response = MagicMock()
@ -525,7 +575,9 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided():
"budget_id": test_new_budget_id,
"litellm_budget_table": None,
}
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response)
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(
return_value=mock_team_membership_response
)
# Call the function with max_budget_in_team provided
result_user, result_team_membership = await add_new_member(
@ -551,7 +603,9 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided():
assert result_team_membership.budget_id == test_new_budget_id
# Verify the team membership was created with the correct budget_id
team_membership_call_args = mock_prisma_client.db.litellm_teammembership.upsert.call_args
team_membership_call_args = (
mock_prisma_client.db.litellm_teammembership.upsert.call_args
)
assert team_membership_call_args is not None
create_data = team_membership_call_args.kwargs["data"]["create"]
assert create_data["budget_id"] == test_new_budget_id
@ -567,7 +621,9 @@ async def test_add_new_member_persists_budget_duration():
from litellm.proxy._types import LitellmUserRoles
new_member = Member(user_id="user-dur", role="user")
user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN)
user_api_key_dict = UserAPIKeyAuth(
user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN
)
mock_prisma_client = AsyncMock()
mock_user_response = MagicMock()
@ -578,10 +634,14 @@ async def test_add_new_member_persists_budget_duration():
"user_role": "internal_user",
}
mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(
return_value=mock_user_response
)
mock_budget_response = MagicMock()
mock_budget_response.budget_id = "budget-dur"
mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_budget_response)
mock_prisma_client.db.litellm_budgettable.create = AsyncMock(
return_value=mock_budget_response
)
mock_team_membership_response = MagicMock()
mock_team_membership_response.model_dump.return_value = {
"team_id": "team-dur",
@ -589,7 +649,9 @@ async def test_add_new_member_persists_budget_duration():
"budget_id": "budget-dur",
"litellm_budget_table": None,
}
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response)
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(
return_value=mock_team_membership_response
)
await add_new_member(
new_member=new_member,
@ -604,7 +666,9 @@ async def test_add_new_member_persists_budget_duration():
)
mock_prisma_client.db.litellm_budgettable.create.assert_called_once()
budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"]
budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs[
"data"
]
assert budget_data["max_budget"] == 10.0
assert budget_data["allowed_models"] == ["gpt-4o-mini"]
assert budget_data["budget_duration"] == "30d"
@ -621,7 +685,9 @@ async def test_add_new_member_persists_budget_duration_without_max_budget():
from litellm.proxy._types import LitellmUserRoles
new_member = Member(user_id="user-dur2", role="user")
user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN)
user_api_key_dict = UserAPIKeyAuth(
user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN
)
mock_prisma_client = AsyncMock()
mock_user_response = MagicMock()
@ -632,10 +698,14 @@ async def test_add_new_member_persists_budget_duration_without_max_budget():
"user_role": "internal_user",
}
mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response)
mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(
return_value=mock_user_response
)
mock_budget_response = MagicMock()
mock_budget_response.budget_id = "budget-dur2"
mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_budget_response)
mock_prisma_client.db.litellm_budgettable.create = AsyncMock(
return_value=mock_budget_response
)
mock_team_membership_response = MagicMock()
mock_team_membership_response.model_dump.return_value = {
"team_id": "team-dur2",
@ -643,7 +713,9 @@ async def test_add_new_member_persists_budget_duration_without_max_budget():
"budget_id": "budget-dur2",
"litellm_budget_table": None,
}
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response)
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(
return_value=mock_team_membership_response
)
_, result_team_membership = await add_new_member(
new_member=new_member,
@ -657,7 +729,9 @@ async def test_add_new_member_persists_budget_duration_without_max_budget():
)
mock_prisma_client.db.litellm_budgettable.create.assert_called_once()
budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"]
budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs[
"data"
]
assert budget_data["budget_duration"] == "7d"
assert budget_data["budget_reset_at"] > datetime.now(timezone.utc)
assert result_team_membership is not None
@ -675,7 +749,9 @@ async def test_add_new_member_with_user_email_links_default_budget():
new_member = Member(user_email=test_user_email, role="user")
user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN)
user_api_key_dict = UserAPIKeyAuth(
user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN
)
mock_prisma_client = AsyncMock()
@ -692,7 +768,9 @@ async def test_add_new_member_with_user_email_links_default_budget():
mock_default_budget_row = MagicMock()
mock_default_budget_row.budget_id = test_default_budget_id
mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_default_budget_row)
mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(
return_value=mock_default_budget_row
)
mock_prisma_client.db.litellm_budgettable.create = AsyncMock()
mock_team_membership_response = MagicMock()
@ -702,7 +780,9 @@ async def test_add_new_member_with_user_email_links_default_budget():
"budget_id": test_default_budget_id,
"litellm_budget_table": None,
}
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response)
mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(
return_value=mock_team_membership_response
)
result_user, result_team_membership = await add_new_member(
new_member=new_member,
@ -922,10 +1002,14 @@ async def test_attach_object_permission_to_dict_with_object_permission_id():
mock_object_permission.model_dump.return_value = expected_object_permission
# Mock the database query
mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=mock_object_permission)
mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(
return_value=mock_object_permission
)
# Call the function
result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client)
result = await attach_object_permission_to_dict(
data_dict=test_data_dict, prisma_client=mock_prisma_client
)
# Verify the result
assert result is not None
@ -957,7 +1041,9 @@ async def test_attach_object_permission_to_dict_without_object_permission_id():
mock_prisma_client = AsyncMock()
# Call the function
result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client)
result = await attach_object_permission_to_dict(
data_dict=test_data_dict, prisma_client=mock_prisma_client
)
# Verify the result is unchanged
assert result == test_data_dict
@ -989,10 +1075,14 @@ async def test_attach_object_permission_to_dict_object_permission_not_found():
mock_prisma_client = AsyncMock()
# Mock the database query to return None (not found)
mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=None)
mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(
return_value=None
)
# Call the function
result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client)
result = await attach_object_permission_to_dict(
data_dict=test_data_dict, prisma_client=mock_prisma_client
)
# Verify the result is unchanged
assert result == test_data_dict
@ -1033,14 +1123,20 @@ async def test_attach_object_permission_to_dict_with_dict_method():
# Mock the object permission response that uses .dict() method
mock_object_permission = MagicMock()
mock_object_permission.model_dump.side_effect = AttributeError("No model_dump method")
mock_object_permission.model_dump.side_effect = AttributeError(
"No model_dump method"
)
mock_object_permission.dict.return_value = expected_object_permission
# Mock the database query
mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=mock_object_permission)
mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(
return_value=mock_object_permission
)
# Call the function
result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client)
result = await attach_object_permission_to_dict(
data_dict=test_data_dict, prisma_client=mock_prisma_client
)
# Verify the result
assert result is not None
@ -1069,8 +1165,7 @@ async def test_attach_object_permission_to_dict_with_none_prisma_client():
# Call the function with None prisma_client
with pytest.raises(ValueError, match="Prisma client not found"):
await attach_object_permission_to_dict(
data_dict=test_data_dict,
prisma_client=None, # type: ignore
data_dict=test_data_dict, prisma_client=None # type: ignore
)
@ -1090,7 +1185,9 @@ async def test_attach_object_permission_to_dict_with_empty_dict():
mock_prisma_client = AsyncMock()
# Call the function
result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client)
result = await attach_object_permission_to_dict(
data_dict=test_data_dict, prisma_client=mock_prisma_client
)
# Verify the result is unchanged
assert result == {}
@ -1120,7 +1217,9 @@ async def test_attach_object_permission_to_dict_with_none_object_permission_id()
mock_prisma_client = AsyncMock()
# Call the function
result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client)
result = await attach_object_permission_to_dict(
data_dict=test_data_dict, prisma_client=mock_prisma_client
)
# Verify the result is unchanged
assert result == test_data_dict
@ -1146,7 +1245,9 @@ async def test_add_new_member_appends_team_only_if_absent_for_existing_user():
from litellm.proxy._types import LitellmUserRoles
new_member = Member(user_id="existing-user", role="user")
user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN)
user_api_key_dict = UserAPIKeyAuth(
user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN
)
mock_prisma_client = AsyncMock()
@ -1217,7 +1318,9 @@ async def test_add_new_member_creates_missing_user_atomically_via_upsert():
from litellm.proxy._types import LitellmUserRoles
new_member = Member(user_id="brand-new-user", role="user")
user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN)
user_api_key_dict = UserAPIKeyAuth(
user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN
)
mock_prisma_client = AsyncMock()
@ -1321,7 +1424,9 @@ async def test_add_new_member_runs_every_write_on_the_caller_transaction(new_mem
max_budget_in_team=50.0,
prisma_client=prisma_client,
team_id="team-pool",
user_api_key_dict=UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN),
user_api_key_dict=UserAPIKeyAuth(
user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN
),
litellm_proxy_admin_name="admin",
tx=tx,
)

View file

@ -1,18 +1,12 @@
import json
from datetime import datetime, timezone
from types import SimpleNamespace
from datetime import datetime
import pytest
from pydantic import ValidationError
from litellm.proxy._types import TeamMemberBudgetBackfillResult, UpdateTeamRequest, UserAPIKeyAuth
from litellm.proxy._types import UpdateTeamRequest
from litellm.proxy.management_helpers.team_member_default_budget import (
MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE,
MovedMemberBudgets,
TooManyMemberBudgetsToMove,
move_member_budgets_to_default,
plan_team_member_default_budget_write,
write_team_member_default_budget,
)
@ -43,8 +37,6 @@ def test_clearing_an_existing_default_updates_it_without_relinking_members():
def test_a_first_default_gets_a_new_row_that_inherits_the_team_reset_period():
before = datetime.now(timezone.utc)
write = _plan(team_budget_duration="30d", team_member_budget=25.0)
assert write is not None
@ -52,7 +44,7 @@ def test_a_first_default_gets_a_new_row_that_inherits_the_team_reset_period():
assert write.create["max_budget"] == 25.0
assert write.create["budget_duration"] == "30d"
reset_at = write.create["budget_reset_at"]
assert isinstance(reset_at, datetime) and reset_at > before
assert isinstance(reset_at, datetime)
assert write.links_members is True
@ -66,14 +58,12 @@ def test_an_explicit_null_reset_period_is_not_replaced_by_the_team_period():
def test_changing_the_reset_period_restarts_the_window():
before = datetime.now(timezone.utc)
write = _plan(existing_budget_id="default-1", team_member_budget_duration="7d")
assert write is not None
assert write.update["budget_duration"] == "7d"
reset_at = write.update["budget_reset_at"]
assert isinstance(reset_at, datetime) and reset_at > before
assert isinstance(reset_at, datetime)
@pytest.mark.parametrize("team_member_budget", [None, 0.0])
@ -90,275 +80,9 @@ def test_keeping_custom_budgets_needs_no_default(backfill):
def test_per_model_member_budgets_are_stored_as_plain_json():
caps = {"gpt-4o": {"max_budget": 5.0, "budget_duration": "1d"}}
caps = {"test-model": {"max_budget": 5.0, "budget_duration": "1d"}}
write = _plan(existing_budget_id="default-1", team_member_model_max_budget=caps)
assert write is not None
assert json.loads(json.dumps(write.update["model_max_budget"]))["gpt-4o"]["max_budget"] == 5.0
class _InMemoryTeam:
"""One team's memberships and budget rows, changed the way the backfill's statements change Postgres."""
def __init__(self, default: dict[str, object], members: dict[str, dict[str, object] | None]) -> None:
self.budgets: dict[str, dict[str, object]] = {"default": {"budget_id": "default", **default}}
self.memberships: dict[str, str | None] = {}
for user_id, budget in members.items():
if budget is None:
self.memberships[user_id] = "default"
continue
self.budgets[f"own-{user_id}"] = {"budget_id": f"own-{user_id}", **budget}
self.memberships[user_id] = f"own-{user_id}"
self.litellm_budgettable = SimpleNamespace(
find_unique=self._find_budget, upsert=self._upsert_budget, create=self._create_budget
)
self.litellm_teammembership = SimpleNamespace(upsert=self._link_membership)
def share(self, budget_id: str, *user_ids: str) -> None:
for user_id in user_ids:
self.memberships[user_id] = budget_id
async def _create_budget(self, data: dict[str, object], include: dict[str, bool] | None = None):
budget_id = f"copy-{len(self.budgets)}"
self.budgets[budget_id] = {"budget_id": budget_id, **data}
return SimpleNamespace(budget_id=budget_id)
async def _link_membership(self, where: dict[str, dict[str, str]], data: dict[str, dict[str, object]]) -> None:
self.memberships[where["user_id_team_id"]["user_id"]] = data["update"]["litellm_budget_table"]["connect"][
"budget_id"
]
def budget_of(self, user_id: str) -> dict[str, object]:
return self.budgets[self.memberships[user_id]]
async def _find_budget(self, where: dict[str, str]):
stored = self.budgets.get(where["budget_id"])
if stored is None:
return None
row = {**_ROW_DEFAULTS, **stored}
return SimpleNamespace(**row, model_dump=lambda: row)
async def _upsert_budget(self, where: dict[str, str], data: dict[str, dict[str, object]]) -> None:
current = self.budgets.get(where["budget_id"])
self.budgets[where["budget_id"]] = {**(current or {}), **(data["update"] if current else data["create"])}
def _on_chosen_side(self, budget: dict[str, object], direction: str, amount: float) -> bool:
own = budget.get("max_budget")
if budget["budget_id"] == "default" or own is None:
return False
return {"raise_to_default": own < amount, "lower_to_default": own > amount, "all_to_default": own != amount}[
direction
]
async def query_raw(self, sql: str, *args: object) -> list[dict[str, object]]:
if "HAVING COUNT(*) > 1" in sql:
budget_ids = list(self.memberships.values())
return [{"budget_id": b} for b in set(args[0]) if budget_ids.count(b) > 1]
_team, _default, direction, amount = args[:4]
chosen = [
(u, self.budgets[b])
for u, b in self.memberships.items()
if b and self._on_chosen_side(self.budgets[b], direction, amount)
]
if "GROUP BY" in sql:
durations = [budget.get("budget_duration") for _, budget in chosen]
return [{"duration": d, "members": durations.count(d)} for d in set(durations)]
durations, include_none = args[4], args[5]
return [
{**_ROW_DEFAULTS, **budget, "user_id": user_id}
for user_id, budget in chosen
if budget.get("budget_duration") in durations or (include_none and budget.get("budget_duration") is None)
]
async def execute_raw(self, sql: str, *args: object) -> int:
if "INSERT INTO" in sql:
for user_id in args[2]:
self.memberships.setdefault(user_id, args[1])
elif "budget_id IS NULL" in sql:
self.memberships = {u: b or args[1] for u, b in self.memberships.items()}
elif "SET budget_reset_at" in sql:
for user_id in args[2]:
if self.memberships[user_id] != args[1]:
self.budget_of(user_id)["budget_reset_at"] = self.budgets[args[1]].get("budget_reset_at")
elif "SET max_budget = NULL" in sql:
for budget_id in args[0]:
self.budgets[budget_id]["max_budget"] = None
elif "SET budget_id = $2" in sql:
for user_id in args[2]:
self.memberships[user_id] = args[1]
return 0
_ROW_DEFAULTS = {
"soft_budget": None,
"max_parallel_requests": None,
"tpm_limit": None,
"rpm_limit": None,
"model_max_budget": None,
"budget_duration": None,
"allowed_models": None,
"temp_budget_increase": None,
"temp_budget_expiry": None,
}
_DEFAULT_RESET = datetime(2030, 1, 1, tzinfo=timezone.utc)
_ADMIN = UserAPIKeyAuth(user_id="admin")
async def _backfill(team: _InMemoryTeam, backfill: str):
return await move_member_budgets_to_default(
team, team_id="team-1", default_budget_id="default", backfill=backfill, changed_by=_ADMIN
)
def _team(**members: dict[str, object] | None) -> _InMemoryTeam:
return _InMemoryTeam({"max_budget": 50.0, "budget_duration": "30d", "budget_reset_at": _DEFAULT_RESET}, members)
@pytest.mark.asyncio
async def test_raise_moves_members_below_the_default_on_its_schedule_and_counts_the_rest():
team = _team(
below={"max_budget": 10.0, "budget_duration": "30d"},
own_rpm={"max_budget": 10.0, "budget_duration": "30d", "rpm_limit": 5, "budget_reset_at": "2030-02-01"},
weekly={"max_budget": 10.0, "budget_duration": "7d"},
above={"max_budget": 80.0, "budget_duration": "30d"},
on_default=None,
)
moved = await _backfill(team, "raise_to_default")
assert isinstance(moved, MovedMemberBudgets)
assert sorted(moved.user_ids) == ["below", "own_rpm"]
assert moved.result() == TeamMemberBudgetBackfillResult(moved_to_default=2, skipped_other_reset_period=1)
assert team.memberships["below"] == "default"
assert team.budget_of("own_rpm") == {
"budget_id": "own-own_rpm",
"max_budget": None,
"budget_duration": "30d",
"rpm_limit": 5,
"budget_reset_at": _DEFAULT_RESET,
}
assert team.budget_of("weekly")["max_budget"] == 10.0
assert team.budget_of("above")["max_budget"] == 80.0
@pytest.mark.asyncio
async def test_a_model_list_matching_the_default_still_keeps_the_members_own_row():
team = _team(scoped={"max_budget": 10.0, "budget_duration": "30d", "allowed_models": ["gpt-5.4-mini"]})
team.budgets["default"]["allowed_models"] = ["gpt-5.4-mini"]
await _backfill(team, "raise_to_default")
assert team.memberships["scoped"] == "own-scoped"
assert team.budget_of("scoped")["max_budget"] is None
@pytest.mark.asyncio
async def test_more_members_than_one_update_may_move_changes_nobody():
members = {
f"m{i}": {"max_budget": 10.0, "budget_duration": "30d"} for i in range(MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + 1)
}
team = _team(**members)
moved = await _backfill(team, "raise_to_default")
assert moved == TooManyMemberBudgetsToMove(count=MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + 1)
assert all(budget_id != "default" for budget_id in team.memberships.values())
@pytest.mark.asyncio
async def test_members_sharing_a_budget_with_their_own_limits_each_get_a_copy_on_the_default():
team = _team()
team.budgets["shared"] = {"budget_id": "shared", "max_budget": 10.0, "budget_duration": "30d", "rpm_limit": 5}
team.share("shared", "first", "second")
moved = await _backfill(team, "raise_to_default")
assert isinstance(moved, MovedMemberBudgets)
assert sorted(moved.user_ids) == ["first", "second"]
copies = {team.memberships["first"], team.memberships["second"]}
assert len(copies) == 2 and "shared" not in copies
assert [(team.budgets[c]["max_budget"], team.budgets[c]["rpm_limit"]) for c in sorted(copies)] == [
(None, 5),
(None, 5),
]
assert team.budgets["shared"]["max_budget"] == 10.0
@pytest.mark.asyncio
async def test_only_members_on_another_schedule_are_counted_and_left_alone():
team = _team(weekly={"max_budget": 10.0, "budget_duration": "7d"})
moved = await _backfill(team, "raise_to_default")
assert moved == MovedMemberBudgets(user_ids=(), skipped_other_reset_period=1)
assert team.memberships["weekly"] == "own-weekly"
@pytest.mark.asyncio
async def test_a_missing_default_row_moves_nobody():
team = _team(below={"max_budget": 10.0, "budget_duration": "30d"})
del team.budgets["default"]
assert await _backfill(team, "raise_to_default") == MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0)
def test_a_first_default_on_a_team_without_an_alias_gets_a_generic_id():
write = plan_team_member_default_budget_write(
data=UpdateTeamRequest(team_id="team-1", team_member_budget=5.0),
existing_budget_id=None,
team_alias=None,
team_budget_duration=None,
)
assert write is not None
assert write.budget_id.startswith("team-budget-")
@pytest.mark.asyncio
async def test_keeping_custom_budgets_moves_nobody():
team = _team(below={"max_budget": 10.0, "budget_duration": "30d"})
assert await _backfill(team, "none") == MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0)
assert team.memberships["below"] == "own-below"
@pytest.mark.asyncio
async def test_writing_a_default_links_roster_members_without_a_budget_to_it():
team = _team(own={"max_budget": 10.0, "budget_duration": "30d"})
team.memberships["unbudgeted"] = None
write = _plan(
existing_budget_id="default",
team_member_budget=60.0,
team_member_model_max_budget={"gpt-4o": {"max_budget": 1.0}},
)
assert write is not None
await write_team_member_default_budget(
team, write, team_id="team-1", member_user_ids=("own", "unbudgeted", "no-row"), changed_by="admin"
)
assert team.budgets["default"]["max_budget"] == 60.0
assert team.budgets["default"]["model_max_budget"].data == {
"gpt-4o": {"max_budget": 1.0, "budget_duration": None, "tpm_limit": None, "rpm_limit": None}
}
assert (team.memberships["unbudgeted"], team.memberships["no-row"], team.memberships["own"]) == (
"default",
"default",
"own-own",
)
@pytest.mark.asyncio
async def test_clearing_the_default_does_not_link_members_without_a_budget_to_it():
team = _team()
team.memberships["unbudgeted"] = None
write = _plan(existing_budget_id="default", team_member_budget=None)
assert write is not None
await write_team_member_default_budget(
team, write, team_id="team-1", member_user_ids=("unbudgeted", "no-row"), changed_by="admin"
)
assert team.budgets["default"]["max_budget"] is None
assert team.memberships == {"unbudgeted": None}
assert json.loads(json.dumps(write.update["model_max_budget"]))["test-model"]["max_budget"] == 5.0