mirror of
https://github.com/BerriAI/litellm.git
synced 2026-11-16 09:22:22 +00:00
Merge 351a60d924 into a42c1c138a
This commit is contained in:
commit
39a6704c16
6 changed files with 494 additions and 60 deletions
|
|
@ -42,10 +42,12 @@ _EMPTY_ROWS: Final[Mapping[DbRow, Mapping[str, JsonValue]]] = MappingProxyType({
|
|||
|
||||
|
||||
class SettingsStore(MutableMapping[str, JsonValue]):
|
||||
def __init__(self, section: Section) -> None:
|
||||
def __init__(self, section: Section, *, managed_db_keys: frozenset[str] | None = None) -> None:
|
||||
self._section: Final = section
|
||||
self._managed_db_keys: Final = managed_db_keys
|
||||
self._yaml_values: Mapping[str, JsonValue] = _EMPTY_VALUES
|
||||
self._database_rows: Mapping[DbRow, Mapping[str, JsonValue]] = _EMPTY_ROWS
|
||||
self._unmanaged_db_keys: frozenset[str] = frozenset()
|
||||
self._runtime_values: Mapping[str, JsonValue] = _EMPTY_VALUES
|
||||
self._deleted_runtime_keys: frozenset[str] = frozenset()
|
||||
|
||||
|
|
@ -77,15 +79,24 @@ class SettingsStore(MutableMapping[str, JsonValue]):
|
|||
return self.owned_by_config(key) and self._db_value_is_shadowed(key)
|
||||
|
||||
def apply_db_row(self, row: DbRow, db_row: Mapping[str, JsonValue]) -> None:
|
||||
applied_row: Final = MappingProxyType({key: db_row[key] for key in db_row if self._db_manages(row, key)})
|
||||
previous_row: Final = self._database_rows.get(row, _EMPTY_VALUES)
|
||||
changed: Final = frozenset(
|
||||
key
|
||||
for key in (*previous_row, *db_row)
|
||||
if previous_row.get(key, ABSENT) != db_row.get(key, ABSENT) # pyright: ignore[reportUnknownArgumentType] # JsonValue vs Absent compare
|
||||
for key in (*previous_row, *applied_row)
|
||||
if previous_row.get(key, ABSENT) != applied_row.get(key, ABSENT) # pyright: ignore[reportUnknownArgumentType] # JsonValue vs Absent compare
|
||||
)
|
||||
self._database_rows = MappingProxyType({**self._database_rows, row: MappingProxyType(dict(db_row))})
|
||||
self._database_rows = MappingProxyType({**self._database_rows, row: applied_row})
|
||||
if row == self._section:
|
||||
self._unmanaged_db_keys = frozenset(key for key in db_row if key not in applied_row)
|
||||
self._clear_runtime_keys(changed)
|
||||
|
||||
def unmanaged_db_keys(self) -> tuple[str, ...]:
|
||||
return tuple(sorted(self._unmanaged_db_keys))
|
||||
|
||||
def _db_manages(self, row: DbRow, key: str) -> bool:
|
||||
return row != self._section or self._managed_db_keys is None or key in self._managed_db_keys
|
||||
|
||||
def resolved(self) -> Mapping[str, JsonValue]:
|
||||
return MappingProxyType(dict(self))
|
||||
|
||||
|
|
|
|||
|
|
@ -5613,6 +5613,14 @@ def _reload_settings_store(section: Section, store: SettingsStore, section_confi
|
|||
store["pass_through_endpoints"] = serving_pass_throughs
|
||||
|
||||
|
||||
def _general_settings_row_is_readable(row: _ConfigParamValueRow | None) -> bool:
|
||||
return row is None or row.param_value is None or isinstance(row.param_value, Mapping)
|
||||
|
||||
|
||||
def _db_managed_general_settings_keys() -> frozenset[str]:
|
||||
return frozenset((*ConfigGeneralSettings.model_fields, *_CLEANUP_SCHEDULE_KEYS, "allowed_ips", "email_settings"))
|
||||
|
||||
|
||||
def _bind_general_settings_store(settings: SettingsStore) -> None:
|
||||
global general_settings
|
||||
general_settings = settings # pyright: ignore[reportAssignmentType] # legacy global accepts mappings
|
||||
|
|
@ -5763,7 +5771,9 @@ class ProxyConfig:
|
|||
# whether an existing request predates the prices it just fetched, and re-serving one
|
||||
# costs a single fetch where skipping one leaves it priced wrong indefinitely
|
||||
self.model_cost_map_applied_revision: int = 0
|
||||
self.settings: Final[SettingsStore] = SettingsStore("general_settings")
|
||||
self.settings: Final[SettingsStore] = SettingsStore(
|
||||
"general_settings", managed_db_keys=_db_managed_general_settings_keys()
|
||||
)
|
||||
self.router_settings: Final[SettingsStore] = SettingsStore("router_settings")
|
||||
self.litellm_settings: Final[SettingsStore] = SettingsStore("litellm_settings")
|
||||
self.environment_variables: Final[SettingsStore] = SettingsStore("environment_variables")
|
||||
|
|
@ -5774,6 +5784,8 @@ class ProxyConfig:
|
|||
self._db_environment_keys: frozenset[str] = frozenset()
|
||||
self._sso_environment_removals: frozenset[str] = frozenset()
|
||||
self._warned_shadowed_keys: frozenset[tuple[Section, str]] = frozenset()
|
||||
self._warned_unmanaged_keys: frozenset[str] = frozenset()
|
||||
self._warned_unreadable_db_general_settings: bool = False
|
||||
self._db_config_callback_entries: Mapping[tuple[str, str], _DbCallbackRegistration] = MappingProxyType({})
|
||||
self._settings_stores: Final[Mapping[Section, SettingsStore]] = MappingProxyType(
|
||||
{
|
||||
|
|
@ -8304,15 +8316,20 @@ class ProxyConfig:
|
|||
general_settings.get("maximum_spend_logs_retention_interval", "1d"),
|
||||
)
|
||||
|
||||
async def _update_general_settings(self, db_general_settings: Mapping[str, SettingsJsonValue] | None) -> None:
|
||||
async def _update_general_settings(self, db_general_settings: Mapping[str, SettingsJsonValue] | str | None) -> None:
|
||||
global general_settings
|
||||
if db_general_settings is None:
|
||||
return
|
||||
if not isinstance(db_general_settings, Mapping):
|
||||
self._warn_about_unreadable_db_general_settings()
|
||||
return
|
||||
self._warned_unreadable_db_general_settings = False
|
||||
if not isinstance(general_settings, SettingsStore):
|
||||
self.settings.load_yaml(_as_settings_mapping(general_settings))
|
||||
cache_size_was_db: Final = self.settings.source("user_api_key_cache_max_size") == "db"
|
||||
previous_cleanup_schedule: Final = self._resolved_cleanup_schedule()
|
||||
self.settings.apply_db_row("general_settings", db_general_settings)
|
||||
self._warn_about_unmanaged_db_settings()
|
||||
_bind_general_settings_store(self.settings)
|
||||
await self._apply_general_settings_side_effects(
|
||||
db_general_settings,
|
||||
|
|
@ -8530,6 +8547,7 @@ class ProxyConfig:
|
|||
)
|
||||
|
||||
self._warn_about_shadowed_db_settings()
|
||||
self._warn_about_unmanaged_db_settings()
|
||||
return self._config_with_resolved_settings(config)
|
||||
|
||||
async def _apply_db_environment_variables_row(
|
||||
|
|
@ -8588,6 +8606,30 @@ class ProxyConfig:
|
|||
)
|
||||
self._warned_shadowed_keys = shadowed
|
||||
|
||||
def _warn_about_unmanaged_db_settings(self) -> None:
|
||||
unmanaged: Final = frozenset(
|
||||
key for key in self.settings.unmanaged_db_keys() if key not in _GENERAL_SETTINGS_UI_LITELLM_FIELDS
|
||||
)
|
||||
for key in sorted(unmanaged - self._warned_unmanaged_keys):
|
||||
verbose_proxy_logger.warning(
|
||||
"general_settings.%s is stored in the database, but the proxy does not apply that stored value, so it "
|
||||
"is ignored. %s",
|
||||
key,
|
||||
"The config file's value applies. Remove the stored copy with POST /config/field/delete."
|
||||
if self.settings.owned_by_config(key)
|
||||
else "Set it in the config file to use it, or remove it with POST /config/field/delete.",
|
||||
)
|
||||
self._warned_unmanaged_keys = unmanaged
|
||||
|
||||
def _warn_about_unreadable_db_general_settings(self) -> None:
|
||||
if self._warned_unreadable_db_general_settings:
|
||||
return
|
||||
verbose_proxy_logger.warning(
|
||||
"general_settings is stored in the database as something other than a JSON object, so the proxy "
|
||||
"ignores every stored general setting."
|
||||
)
|
||||
self._warned_unreadable_db_general_settings = True
|
||||
|
||||
def _prepared_db_settings_values(self, section: Section, value: object) -> Mapping[str, SettingsJsonValue]:
|
||||
scrubbed: Final = _scrub_db_overlay_remote_module_loads(section=section, db_value=value)
|
||||
return _as_settings_mapping(scrubbed)
|
||||
|
|
@ -8754,7 +8796,10 @@ class ProxyConfig:
|
|||
)
|
||||
|
||||
# initialize vector stores, guardrails, etc. table in db
|
||||
await self._init_non_llm_objects_in_db(prisma_client=prisma_client)
|
||||
await self._init_non_llm_objects_in_db(
|
||||
prisma_client=prisma_client,
|
||||
refresh_pass_through_endpoints=_general_settings_row_is_readable(db_general_settings),
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
verbose_proxy_logger.exception("litellm.proxy.proxy_server.py::ProxyConfig:add_deployment - %s", e)
|
||||
|
|
@ -8823,7 +8868,9 @@ class ProxyConfig:
|
|||
except Exception as e: # noqa: BLE001 # best-effort: a failing stop must not break proxy shutdown
|
||||
verbose_proxy_logger.error("Error stopping auth cache invalidation subscriber: %s", e)
|
||||
|
||||
async def _init_non_llm_objects_in_db(self, prisma_client: PrismaClient):
|
||||
async def _init_non_llm_objects_in_db(
|
||||
self, prisma_client: PrismaClient, *, refresh_pass_through_endpoints: bool = True
|
||||
):
|
||||
"""
|
||||
Use this to read non-llm objects from the db and initialize them
|
||||
|
||||
|
|
@ -8847,7 +8894,7 @@ class ProxyConfig:
|
|||
if self._should_load_db_object(object_type="agents"):
|
||||
await self._init_agents_in_db(prisma_client=prisma_client)
|
||||
|
||||
if self._should_load_db_object(object_type="pass_through_endpoints"):
|
||||
if refresh_pass_through_endpoints and self._should_load_db_object(object_type="pass_through_endpoints"):
|
||||
await self._init_pass_through_endpoints_in_db()
|
||||
|
||||
if self._should_load_db_object(object_type="prompts"):
|
||||
|
|
@ -20721,53 +20768,56 @@ async def delete_config_general_settings(
|
|||
if data.field_name in _GENERAL_SETTINGS_UI_LITELLM_FIELDS:
|
||||
return await _reset_general_settings_ui_litellm_field(data.field_name, user_api_key_dict)
|
||||
|
||||
if data.field_name not in ConfigGeneralSettings.model_fields:
|
||||
config_table: Final[TableActions[_ConfigParamValueRow]] = _config_param_table(prisma_client)
|
||||
stored_row: Final = await config_table.find_first(where={"param_name": "general_settings"})
|
||||
stored: Final = (
|
||||
_SETTINGS_MAPPING.validate_python(stored_row.param_value)
|
||||
if stored_row is not None and isinstance(stored_row.param_value, Mapping)
|
||||
else None
|
||||
)
|
||||
|
||||
if not _general_settings_row_is_readable(stored_row):
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail={
|
||||
"error": "general_settings is stored in the database as something other than a JSON object, so no "
|
||||
"field can be removed from it"
|
||||
},
|
||||
)
|
||||
|
||||
if data.field_name not in ConfigGeneralSettings.model_fields and (stored is None or data.field_name not in stored):
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail={"error": f"Invalid field={data.field_name} passed in."},
|
||||
)
|
||||
|
||||
proxy_config.reject_config_owned_deletes(section_name="general_settings", keys=(data.field_name,))
|
||||
if data.field_name in _db_managed_general_settings_keys():
|
||||
proxy_config.reject_config_owned_deletes(section_name="general_settings", keys=(data.field_name,))
|
||||
|
||||
## get general settings from db
|
||||
db_general_settings: Final[_ConfigParamRow | None] = await _config_param_table(prisma_client).find_first(
|
||||
where={"param_name": "general_settings"}
|
||||
)
|
||||
### pop the value
|
||||
|
||||
if db_general_settings is None or db_general_settings.param_value is None:
|
||||
if stored is None:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail={"error": f"Field name={data.field_name} not in config"},
|
||||
)
|
||||
else:
|
||||
general_settings = dict(db_general_settings.param_value)
|
||||
|
||||
before_general_settings: Final = copy.deepcopy(general_settings)
|
||||
|
||||
## update db
|
||||
|
||||
general_settings.pop(data.field_name, None)
|
||||
|
||||
remaining: Final = {key: value for key, value in stored.items() if key != data.field_name}
|
||||
response: Final = await ConfigRepository(prisma_client).table.upsert(
|
||||
where={"param_name": "general_settings"},
|
||||
data={
|
||||
"create": {
|
||||
"param_name": "general_settings",
|
||||
"param_value": json.dumps(general_settings),
|
||||
"param_value": json.dumps(remaining),
|
||||
},
|
||||
"update": {"param_value": json.dumps(general_settings)},
|
||||
"update": {"param_value": json.dumps(remaining)},
|
||||
},
|
||||
)
|
||||
await invalidate_config_param("general_settings")
|
||||
proxy_config.settings.apply_db_row("general_settings", general_settings)
|
||||
proxy_config.settings.apply_db_row("general_settings", remaining)
|
||||
if is_resource_list("general_settings", data.field_name):
|
||||
stored_endpoints: Final = general_settings.get("pass_through_endpoints")
|
||||
stored_endpoints: Final = remaining.get("pass_through_endpoints")
|
||||
await proxy_config.serve_pass_through_endpoints(stored_endpoints if isinstance(stored_endpoints, list) else ())
|
||||
asyncio.create_task(
|
||||
create_config_audit_log(
|
||||
"general_settings", "deleted", before_general_settings, general_settings, user_api_key_dict
|
||||
)
|
||||
create_config_audit_log("general_settings", "deleted", dict(stored), remaining, user_api_key_dict)
|
||||
)
|
||||
|
||||
return response
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ from pydantic import BaseModel, JsonValue, TypeAdapter
|
|||
|
||||
from tests.integration._support.client import Gateway, eventually, object_value, string_value
|
||||
from tests.integration._support.database import read_rows, scratch_database
|
||||
from tests.integration._support.process import owned_proxy
|
||||
from tests.integration._support.process import owned_proxy, owned_proxy_process
|
||||
from tests.integration._support.wire import Reply, Request, Wire, wire_server
|
||||
|
||||
pytestmark: Final = pytest.mark.shares_worker_state
|
||||
|
|
@ -1701,3 +1701,57 @@ def test_db_environment_variables_saved_from_a_session_outside_the_tables_schema
|
|||
|
||||
assert isinstance(first, int) and isinstance(second, int)
|
||||
assert 0 < first < second
|
||||
|
||||
|
||||
def test_a_stored_general_setting_no_settings_api_manages_stays_off_and_the_rest_of_the_row_applies(
|
||||
gateway: Gateway, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
alias: Final = "stale-database-setting-" + uuid.uuid4().hex
|
||||
with scratch_database() as database_url, wire_server(lambda _request: _completion_reply("pong")) as provider:
|
||||
monkeypatch.setenv("DATABASE_URL", database_url)
|
||||
_push_schema()
|
||||
with psycopg.connect(database_url, autocommit=True) as writer:
|
||||
writer.execute(
|
||||
'INSERT INTO "LiteLLM_Config" (param_name, param_value) VALUES (%s, %s)',
|
||||
("general_settings", Jsonb({"enforce_user_param": True, "store_prompts_in_spend_logs": True})),
|
||||
)
|
||||
config: Final = tmp_path / "stale-database-setting.yaml"
|
||||
config.write_text(
|
||||
json.dumps(
|
||||
{
|
||||
"model_list": [
|
||||
{
|
||||
"model_name": alias,
|
||||
"litellm_params": {
|
||||
"model": "openai/gpt-4o-mini",
|
||||
"api_base": provider.url + "/v1",
|
||||
"api_key": "integration-provider-key",
|
||||
},
|
||||
}
|
||||
],
|
||||
"general_settings": {"master_key": gateway.key, "store_model_in_db": True},
|
||||
}
|
||||
)
|
||||
)
|
||||
with owned_proxy_process(
|
||||
gateway,
|
||||
tmp_path / "stale-database-setting",
|
||||
{"DATABASE_URL": database_url, "DISABLE_SCHEMA_UPDATE": "true"},
|
||||
config=config,
|
||||
database_setup=(),
|
||||
) as owned:
|
||||
answer: Final = owned.gateway.request(
|
||||
"POST", "/v1/chat/completions", {"model": alias, "messages": [{"role": "user", "content": "ping"}]}
|
||||
)
|
||||
listed: Final = owned.gateway.request("GET", "/config/list", params={"config_type": "general_settings"})
|
||||
log: Final = owned.log.read_text()
|
||||
|
||||
assert answer.status_code == 200, answer.text
|
||||
assert listed.status_code == 200, listed.text
|
||||
stored_prompts: Final = next(
|
||||
entry
|
||||
for entry in TypeAdapter(list[dict[str, JsonValue]]).validate_json(listed.content)
|
||||
if entry["field_name"] == "store_prompts_in_spend_logs"
|
||||
)
|
||||
assert (stored_prompts["field_value"], stored_prompts["source"]) == (True, "db")
|
||||
assert "general_settings.enforce_user_param is stored in the database, but the proxy does not apply" in log
|
||||
|
|
|
|||
|
|
@ -471,3 +471,34 @@ def test_settings_store_truthiness_matches_emptiness() -> None:
|
|||
assert bool(store) is True
|
||||
del store["max_parallel_requests"]
|
||||
assert bool(store) is False
|
||||
|
||||
|
||||
def test_settings_store_ignores_stored_keys_outside_its_managed_db_keys_and_still_applies_them_from_yaml() -> None:
|
||||
store: Final = SettingsStore("general_settings", managed_db_keys=frozenset({"max_parallel_requests"}))
|
||||
stored_row: Final[dict[str, JsonValue]] = {"enforce_user_param": True, "max_parallel_requests": 5}
|
||||
|
||||
store.apply_db_row("general_settings", stored_row)
|
||||
|
||||
assert dict(store) == {"max_parallel_requests": 5}
|
||||
assert store.source("enforce_user_param") == "unset"
|
||||
assert store.unmanaged_db_keys() == ("enforce_user_param",)
|
||||
|
||||
store.load_yaml({"enforce_user_param": True})
|
||||
store.apply_db_row("general_settings", stored_row)
|
||||
|
||||
assert dict(store) == {"enforce_user_param": True, "max_parallel_requests": 5}
|
||||
assert store.source("enforce_user_param") == "config"
|
||||
assert store.unmanaged_db_keys() == ("enforce_user_param",)
|
||||
|
||||
|
||||
def test_settings_store_managed_db_keys_leave_other_rows_and_unrestricted_stores_whole() -> None:
|
||||
restricted: Final = SettingsStore("general_settings", managed_db_keys=frozenset())
|
||||
unrestricted: Final = SettingsStore("general_settings")
|
||||
|
||||
restricted.apply_db_row("ui_settings", {"disable_custom_api_keys": True})
|
||||
unrestricted.apply_db_row("general_settings", {"enforce_user_param": True})
|
||||
|
||||
assert dict(restricted) == {"disable_custom_api_keys": True}
|
||||
assert restricted.unmanaged_db_keys() == ()
|
||||
assert dict(unrestricted) == {"enforce_user_param": True}
|
||||
assert unrestricted.unmanaged_db_keys() == ()
|
||||
|
|
|
|||
|
|
@ -102,7 +102,9 @@ def test_proxy_config_upserts_existing_deployment_without_duplicating_it(monkeyp
|
|||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_proxy_config_preserves_models_when_config_read_fails(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
async def test_proxy_config_preserves_models_when_config_read_fails(
|
||||
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
from litellm.proxy import proxy_server
|
||||
|
||||
router = litellm.Router(model_list=[_deployment("config-deployment").to_json(exclude_none=True)])
|
||||
|
|
@ -135,6 +137,8 @@ async def test_proxy_config_keeps_database_models_and_deletes_stale_models(
|
|||
|
||||
assert desired == frozenset({"kept-deployment"})
|
||||
assert router.get_model_ids() == ["kept-deployment"]
|
||||
|
||||
|
||||
from tests._master_key import MASTER_KEY
|
||||
|
||||
|
||||
|
|
@ -150,7 +154,6 @@ async def test_proxy_config_loads_lens_store_from_yaml(tmp_path, monkeypatch) ->
|
|||
assert is_lens_tracing_enabled(settings["tracing"], {}) is True
|
||||
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@pytest.mark.parametrize("shutdown_error", [False, True])
|
||||
async def test_tracing_config_automatically_exports_spend_without_a_storage_dependency(
|
||||
|
|
@ -176,7 +179,9 @@ async def test_tracing_config_automatically_exports_spend_without_a_storage_depe
|
|||
outcome: Final = pytest.raises(RuntimeError, match="shutdown failure") if shutdown_error else nullcontext()
|
||||
with outcome:
|
||||
async with manage_tracing(enabled=True, client_factory=client):
|
||||
logger: Final = next(callback for callback in litellm._async_success_callback if isinstance(callback, LensExporter))
|
||||
logger: Final = next(
|
||||
callback for callback in litellm._async_success_callback if isinstance(callback, LensExporter)
|
||||
)
|
||||
await logger.async_log_success_event(
|
||||
{"standard_logging_object": {"id": "response-1", "response_cost": 0.25}}, None, None, None
|
||||
)
|
||||
|
|
@ -2700,7 +2705,6 @@ async def test_load_config_rejects_non_boolean_deny_by_default(
|
|||
await ProxyConfig().load_config(router=None, config_file_path=str(config_file))
|
||||
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@pytest.mark.parametrize(
|
||||
"yaml_value", ["files-api-2025-04-14", "[files-api-2025-04-14, 7]"], ids=["bare-string", "non-string-entry"]
|
||||
|
|
@ -2720,6 +2724,7 @@ async def test_load_config_rejects_a_malformed_vertex_drop_anthropic_betas_list(
|
|||
with pytest.raises(ValidationError, match="vertex_ai_pass_through_drop_anthropic_betas"):
|
||||
await ProxyConfig().load_config(router=None, config_file_path=str(config_file))
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_ProxyConfig_load_config_resolves_router_settings_plugins(tmp_path, monkeypatch):
|
||||
"""Regression: router_settings.plugins dotted-path strings must be resolved to
|
||||
|
|
@ -4477,6 +4482,86 @@ async def test_ProxyConfig__update_general_settings_updates_health_check_retenti
|
|||
reschedule.assert_awaited_once()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_ProxyConfig__update_general_settings_ignores_a_stored_key_no_settings_api_manages_and_warns_once(
|
||||
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
|
||||
) -> None:
|
||||
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", {})
|
||||
pc: Final = ProxyConfig()
|
||||
stored_row: Final = {"enforce_user_param": True, "store_prompts_in_spend_logs": True}
|
||||
|
||||
with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"):
|
||||
await pc._update_general_settings(stored_row)
|
||||
await pc._update_general_settings(stored_row)
|
||||
from litellm.proxy import proxy_server
|
||||
|
||||
assert proxy_server.general_settings["store_prompts_in_spend_logs"] is True
|
||||
assert "enforce_user_param" not in proxy_server.general_settings
|
||||
warnings: Final = [record.getMessage() for record in caplog.records if "enforce_user_param" in record.getMessage()]
|
||||
assert warnings == [
|
||||
"general_settings.enforce_user_param is stored in the database, but the proxy does not apply that stored "
|
||||
"value, so it is ignored. Set it in the config file to use it, or remove it with POST /config/field/delete."
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_ProxyConfig__update_general_settings_warns_about_an_ignored_stored_key_the_config_file_also_sets(
|
||||
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
|
||||
) -> None:
|
||||
pc: Final = ProxyConfig()
|
||||
pc._load_yaml_settings_stores({"general_settings": {"enforce_user_param": False}})
|
||||
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", pc.settings)
|
||||
|
||||
with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"):
|
||||
await pc._update_general_settings({"enforce_user_param": True})
|
||||
from litellm.proxy import proxy_server
|
||||
|
||||
assert proxy_server.general_settings["enforce_user_param"] is False
|
||||
warnings: Final = [record.getMessage() for record in caplog.records if "enforce_user_param" in record.getMessage()]
|
||||
assert warnings == [
|
||||
"general_settings.enforce_user_param is stored in the database, but the proxy does not apply that stored "
|
||||
"value, so it is ignored. The config file's value applies. Remove the stored copy with POST "
|
||||
"/config/field/delete."
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_ProxyConfig__update_general_settings_does_not_warn_about_a_stored_copy_of_an_admin_ui_field(
|
||||
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
|
||||
) -> None:
|
||||
pc: Final = ProxyConfig()
|
||||
pc._load_yaml_settings_stores({"general_settings": {}})
|
||||
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", pc.settings)
|
||||
|
||||
with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"):
|
||||
await pc._update_general_settings({"budget_rollover": True, "enforce_user_param": True})
|
||||
|
||||
warned: Final = [record.getMessage().split(" ")[0] for record in caplog.records if "is ignored" in record.getMessage()]
|
||||
assert warned == ["general_settings.enforce_user_param"]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_ProxyConfig__update_general_settings_warns_once_each_time_the_stored_row_stops_being_an_object(
|
||||
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
|
||||
) -> None:
|
||||
pc: Final = ProxyConfig()
|
||||
pc._load_yaml_settings_stores({"general_settings": {}})
|
||||
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", pc.settings)
|
||||
|
||||
with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"):
|
||||
await pc._update_general_settings(None)
|
||||
await pc._update_general_settings('{"store_prompts_in_spend_logs": true}')
|
||||
await pc._update_general_settings('{"store_prompts_in_spend_logs": true}')
|
||||
await pc._update_general_settings({"store_prompts_in_spend_logs": True})
|
||||
await pc._update_general_settings('{"store_prompts_in_spend_logs": true}')
|
||||
|
||||
warnings: Final = [record.getMessage() for record in caplog.records if "JSON object" in record.getMessage()]
|
||||
assert warnings == [
|
||||
"general_settings is stored in the database as something other than a JSON object, so the proxy ignores "
|
||||
"every stored general setting."
|
||||
] * 2
|
||||
|
||||
|
||||
def _paused_scheduler(monkeypatch):
|
||||
from apscheduler.schedulers.asyncio import AsyncIOScheduler
|
||||
|
||||
|
|
@ -4925,9 +5010,6 @@ async def test_ProxyConfig__update_general_settings_none_input_noop():
|
|||
# None input returns early.
|
||||
result = await pc._update_general_settings(db_general_settings=None)
|
||||
assert result is None
|
||||
# Error-style: dict() will fail on non-mapping non-None input.
|
||||
with pytest.raises(TypeError):
|
||||
await pc._update_general_settings(db_general_settings=12345) # type: ignore[arg-type]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
|
|
@ -5087,7 +5169,9 @@ async def test_ProxyConfig__update_config_from_db_keeps_keys_the_config_file_omi
|
|||
|
||||
@pytest.mark.asyncio
|
||||
@pytest.mark.parametrize("ui_settings_already_synced", [False, True])
|
||||
async def test_ProxyConfig_add_deployment_continues_after_null_pass_through_endpoints(monkeypatch, ui_settings_already_synced):
|
||||
async def test_ProxyConfig_add_deployment_continues_after_null_pass_through_endpoints(
|
||||
monkeypatch: pytest.MonkeyPatch, ui_settings_already_synced: bool
|
||||
) -> None:
|
||||
from litellm.proxy import proxy_server
|
||||
|
||||
pc = ProxyConfig()
|
||||
|
|
@ -5113,6 +5197,32 @@ async def test_ProxyConfig_add_deployment_continues_after_null_pass_through_endp
|
|||
assert settings_refresh.await_count == (0 if ui_settings_already_synced else 1)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@pytest.mark.parametrize(
|
||||
"stored_row, rebuilds_routes",
|
||||
[({"pass_through_endpoints": []}, True), ('{"pass_through_endpoints": []}', False), ([], False)],
|
||||
ids=["object", "json-string", "array"],
|
||||
)
|
||||
async def test_ProxyConfig_add_deployment_rebuilds_pass_through_routes_only_from_an_object_general_settings_row(
|
||||
monkeypatch: pytest.MonkeyPatch, stored_row: object, rebuilds_routes: bool
|
||||
) -> None:
|
||||
from litellm.proxy import proxy_server
|
||||
from litellm.proxy.pass_through_endpoints import pass_through_endpoints
|
||||
|
||||
pc: Final = ProxyConfig()
|
||||
rebuild_routes: Final = AsyncMock()
|
||||
monkeypatch.setattr(proxy_server, "general_settings", {})
|
||||
monkeypatch.setattr(proxy_server, "prefetch_config_params", AsyncMock())
|
||||
monkeypatch.setattr(proxy_server, "get_config_param", AsyncMock(return_value=SimpleNamespace(param_value=stored_row)))
|
||||
monkeypatch.setattr(pass_through_endpoints, "initialize_pass_through_endpoints_in_db", rebuild_routes)
|
||||
monkeypatch.setattr(pc, "_should_load_db_object", lambda *, object_type: object_type == "pass_through_endpoints")
|
||||
monkeypatch.setattr(pc, "get_credentials", AsyncMock())
|
||||
|
||||
await pc.add_deployment(prisma_client=MagicMock(), proxy_logging_obj=MagicMock(), ui_settings_already_synced=True)
|
||||
|
||||
assert rebuild_routes.await_count == (1 if rebuilds_routes else 0)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# ProxyConfig._update_config_from_db
|
||||
# ---------------------------------------------------------------------------
|
||||
|
|
@ -5292,9 +5402,7 @@ def revision_test_environment(monkeypatch: pytest.MonkeyPatch) -> None:
|
|||
monkeypatch.delenv(key)
|
||||
|
||||
|
||||
def _environment_variables_row(
|
||||
values: Mapping[str, str | None] | None, revision: int | None
|
||||
) -> SimpleNamespace | None:
|
||||
def _environment_variables_row(values: Mapping[str, str | None] | None, revision: int | None) -> SimpleNamespace | None:
|
||||
if values is None:
|
||||
return None
|
||||
return SimpleNamespace(
|
||||
|
|
@ -5480,9 +5588,7 @@ async def test_environment_variables_row_read_before_an_overlapping_newer_sync_i
|
|||
await newer_sync_finished.wait()
|
||||
|
||||
older_sync: Final = asyncio.create_task(
|
||||
_sync_from(
|
||||
pc, _config_database(read_older_row, AsyncMock(return_value=older_row), wait_for_the_newer_sync)
|
||||
)
|
||||
_sync_from(pc, _config_database(read_older_row, AsyncMock(return_value=older_row), wait_for_the_newer_sync))
|
||||
)
|
||||
await older_environment_row_read.wait()
|
||||
await _sync_from(pc, _rows_database(newer_row, newer_row))
|
||||
|
|
|
|||
|
|
@ -1795,9 +1795,7 @@ class _DatabaseWithOneStoredCredential:
|
|||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@pytest.mark.parametrize(
|
||||
"encrypted_with, asks_to_migrate", [(PUBLICLY_KNOWN_KEY, True), ("sk-some-other-key", False)]
|
||||
)
|
||||
@pytest.mark.parametrize("encrypted_with, asks_to_migrate", [(PUBLICLY_KNOWN_KEY, True), ("sk-some-other-key", False)])
|
||||
async def test_proxy_startup_asks_to_migrate_only_when_the_database_holds_values_under_the_unsafe_key(
|
||||
monkeypatch, tmp_path, encrypted_with, asks_to_migrate
|
||||
):
|
||||
|
|
@ -1880,9 +1878,7 @@ async def test_proxy_startup_names_the_config_file_that_set_the_unsafe_key(monke
|
|||
from litellm.proxy.auth.master_key_boot_check import UnsafeMasterKeyError
|
||||
from litellm.proxy.proxy_server import proxy_startup_event
|
||||
|
||||
config_path, announced = _boot_with_general_settings(
|
||||
monkeypatch, tmp_path, {"master_key": PUBLICLY_KNOWN_KEY}
|
||||
)
|
||||
config_path, announced = _boot_with_general_settings(monkeypatch, tmp_path, {"master_key": PUBLICLY_KNOWN_KEY})
|
||||
|
||||
with pytest.raises(UnsafeMasterKeyError):
|
||||
async with proxy_startup_event(FastAPI()):
|
||||
|
|
@ -3763,6 +3759,24 @@ async def test_db_reload_keeps_the_resolved_value_of_a_config_owned_env_referenc
|
|||
assert proxy_server_module.store_model_in_db is True
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_db_reload_of_a_json_string_general_settings_row_reports_no_ignored_keys(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
from litellm.proxy import proxy_server as proxy_server_module
|
||||
from litellm.proxy.proxy_server import ProxyConfig
|
||||
|
||||
monkeypatch.setattr(proxy_server_module, "user_api_key_cache", MagicMock(), raising=False)
|
||||
proxy_config: Final = ProxyConfig()
|
||||
proxy_config.settings.load_yaml({})
|
||||
monkeypatch.setattr(proxy_server_module, "general_settings", proxy_config.settings, raising=False)
|
||||
|
||||
await proxy_config._update_general_settings('{"budget_rollover": true, "master_key": "sk-stored"}')
|
||||
|
||||
assert proxy_config.settings.unmanaged_db_keys() == ()
|
||||
assert proxy_config.settings.source("master_key") != "db"
|
||||
|
||||
|
||||
def test_max_ui_session_budget_default_is_one_dollar():
|
||||
"""LIT-4662: the dashboard session budget default is a product decision; the
|
||||
old 0.25 default locked admins out of auto router Test Connection and the
|
||||
|
|
@ -7251,7 +7265,7 @@ def test_deep_merge_dicts_skips_none_and_empty_lists(monkeypatch):
|
|||
db_param_value = {
|
||||
"max_parallel_requests": None,
|
||||
"allowed_models": [],
|
||||
"new_key": "new_value",
|
||||
"store_prompts_in_spend_logs": True,
|
||||
"nested": {
|
||||
"key1": "updated_value1",
|
||||
"key3": "value3",
|
||||
|
|
@ -7264,7 +7278,7 @@ def test_deep_merge_dicts_skips_none_and_empty_lists(monkeypatch):
|
|||
|
||||
assert result["max_parallel_requests"] == 10
|
||||
assert result["allowed_models"] == ["gpt-3.5-turbo", "gpt-4"]
|
||||
assert result["new_key"] == "new_value"
|
||||
assert result["store_prompts_in_spend_logs"] is True
|
||||
assert result["nested"] == {"key1": "value1", "key2": "value2"}
|
||||
|
||||
|
||||
|
|
@ -8350,10 +8364,18 @@ async def test_update_general_settings_db_pass_through_endpoint_overrides_yaml_e
|
|||
request.headers = {}
|
||||
request.query_params = {}
|
||||
|
||||
settings: Final = patch("litellm.proxy.proxy_server.general_settings", {"pass_through_endpoints": [yaml_endpoint]}) # test-quality-ok: the method reads this module global; no injection seam
|
||||
yaml_endpoints: Final = patch("litellm.proxy.proxy_server.config_passthrough_endpoints", [yaml_endpoint]) # test-quality-ok: module global holding the YAML endpoints the fix merges in
|
||||
initialize: Final = patch("litellm.proxy.proxy_server.initialize_pass_through_endpoints", AsyncMock()) # test-quality-ok: route registration needs the FastAPI app; auth is the observable here
|
||||
master_key: Final = patch("litellm.proxy.proxy_server.master_key", MASTER_KEY) # test-quality-ok: a set master key is what makes a missing Authorization header a 401
|
||||
settings: Final = patch(
|
||||
"litellm.proxy.proxy_server.general_settings", {"pass_through_endpoints": [yaml_endpoint]}
|
||||
) # test-quality-ok: the method reads this module global; no injection seam
|
||||
yaml_endpoints: Final = patch(
|
||||
"litellm.proxy.proxy_server.config_passthrough_endpoints", [yaml_endpoint]
|
||||
) # test-quality-ok: module global holding the YAML endpoints the fix merges in
|
||||
initialize: Final = patch(
|
||||
"litellm.proxy.proxy_server.initialize_pass_through_endpoints", AsyncMock()
|
||||
) # test-quality-ok: route registration needs the FastAPI app; auth is the observable here
|
||||
master_key: Final = patch(
|
||||
"litellm.proxy.proxy_server.master_key", MASTER_KEY
|
||||
) # test-quality-ok: a set master key is what makes a missing Authorization header a 401
|
||||
with settings, yaml_endpoints, initialize, master_key:
|
||||
await ProxyConfig()._update_general_settings(db_general_settings={"pass_through_endpoints": [db_endpoint]})
|
||||
|
||||
|
|
@ -15748,6 +15770,166 @@ async def test_delete_config_general_settings_still_removes_a_key_the_database_o
|
|||
assert "max_request_size_mb" not in pc.settings
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_delete_config_general_settings_removes_a_stored_key_no_settings_api_manages(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
from litellm.proxy._types import ConfigFieldDelete
|
||||
from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings
|
||||
|
||||
pc: Final = ProxyConfig()
|
||||
pc._load_yaml_settings_stores({"general_settings": {}})
|
||||
stored_row: Final = {"enforce_user_param": True, "store_prompts_in_spend_logs": True}
|
||||
pc.settings.apply_db_row("general_settings", stored_row)
|
||||
fake_prisma: Final = _fake_prisma_with_config(stored_row)
|
||||
monkeypatch.setattr(proxy_server_module, "proxy_config", pc)
|
||||
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
|
||||
|
||||
admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
|
||||
await delete_config_general_settings(
|
||||
data=ConfigFieldDelete(field_name="enforce_user_param", config_type="general_settings"),
|
||||
user_api_key_dict=admin,
|
||||
)
|
||||
|
||||
written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"])
|
||||
assert written == {"store_prompts_in_spend_logs": True}
|
||||
assert pc.settings.unmanaged_db_keys() == ()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_delete_config_general_settings_stops_serving_the_removed_pass_through_routes(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
from fastapi import FastAPI
|
||||
from starlette.routing import Route
|
||||
|
||||
from litellm.proxy._types import ConfigFieldDelete
|
||||
from litellm.proxy.pass_through_endpoints.pass_through_endpoints import _registered_pass_through_routes
|
||||
from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings
|
||||
from litellm.types.passthrough_endpoints.pass_through_endpoints import LITELLM_PASS_THROUGH_ENDPOINT_MARKER
|
||||
|
||||
endpoint: Final = {"id": "stored-route", "path": "/stored-route", "target": "http://example.com"}
|
||||
stored_row: Final = {"pass_through_endpoints": [endpoint], "store_prompts_in_spend_logs": True}
|
||||
app: Final = FastAPI()
|
||||
monkeypatch.setattr(proxy_server_module, "app", app)
|
||||
monkeypatch.setattr(proxy_server_module, "premium_user", True)
|
||||
monkeypatch.setattr(proxy_server_module, "config_passthrough_endpoints", None)
|
||||
pc: Final = ProxyConfig()
|
||||
pc._load_yaml_settings_stores({"general_settings": {}})
|
||||
pc.settings.apply_db_row("general_settings", stored_row)
|
||||
monkeypatch.setattr(proxy_server_module, "proxy_config", pc)
|
||||
monkeypatch.setattr(proxy_server_module, "prisma_client", _fake_prisma_with_config(stored_row))
|
||||
|
||||
def served_paths() -> frozenset[str]:
|
||||
return frozenset(
|
||||
route.path
|
||||
for route in app.router.routes
|
||||
if isinstance(route, Route) and getattr(route.endpoint, LITELLM_PASS_THROUGH_ENDPOINT_MARKER, False) is True
|
||||
)
|
||||
|
||||
saved_registry: Final = dict(_registered_pass_through_routes)
|
||||
try:
|
||||
_registered_pass_through_routes.clear()
|
||||
await pc.serve_pass_through_endpoints([endpoint])
|
||||
served_before: Final = served_paths()
|
||||
await delete_config_general_settings(
|
||||
data=ConfigFieldDelete(field_name="pass_through_endpoints", config_type="general_settings"),
|
||||
user_api_key_dict=UserAPIKeyAuth(
|
||||
api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN
|
||||
),
|
||||
)
|
||||
served_after: Final = served_paths()
|
||||
finally:
|
||||
_registered_pass_through_routes.clear()
|
||||
_registered_pass_through_routes.update(saved_registry)
|
||||
|
||||
assert "/stored-route" in served_before
|
||||
assert "/stored-route" not in served_after
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_delete_config_general_settings_removes_an_ignored_stored_key_the_config_file_also_sets(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
from litellm.proxy._types import ConfigFieldDelete
|
||||
from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings
|
||||
|
||||
pc: Final = ProxyConfig()
|
||||
pc._load_yaml_settings_stores({"general_settings": {"enforce_user_param": False}})
|
||||
stored_row: Final = {"enforce_user_param": True, "store_prompts_in_spend_logs": True}
|
||||
pc.settings.apply_db_row("general_settings", stored_row)
|
||||
fake_prisma: Final = _fake_prisma_with_config(stored_row)
|
||||
monkeypatch.setattr(proxy_server_module, "proxy_config", pc)
|
||||
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
|
||||
|
||||
admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
|
||||
await delete_config_general_settings(
|
||||
data=ConfigFieldDelete(field_name="enforce_user_param", config_type="general_settings"),
|
||||
user_api_key_dict=admin,
|
||||
)
|
||||
|
||||
written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"])
|
||||
assert written == {"store_prompts_in_spend_logs": True}
|
||||
assert pc.settings["enforce_user_param"] is False
|
||||
assert pc.settings.unmanaged_db_keys() == ()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@pytest.mark.parametrize("stored_row", ['{"max_request_size_mb": 42, "disable_custom_api_keys": true}', "not json"])
|
||||
@pytest.mark.parametrize("field_name", ["max_request_size_mb", "disable_custom_api_keys", "not_a_setting"])
|
||||
async def test_delete_config_general_settings_leaves_a_string_row_untouched(
|
||||
monkeypatch: pytest.MonkeyPatch, stored_row: str, field_name: str
|
||||
) -> None:
|
||||
from litellm.proxy._types import ConfigFieldDelete
|
||||
from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings
|
||||
|
||||
pc: Final = ProxyConfig()
|
||||
pc._load_yaml_settings_stores({"general_settings": {}})
|
||||
fake_prisma: Final = _fake_prisma_with_config(stored_row)
|
||||
monkeypatch.setattr(proxy_server_module, "proxy_config", pc)
|
||||
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
|
||||
|
||||
admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
|
||||
with pytest.raises(HTTPException) as refused:
|
||||
await delete_config_general_settings(
|
||||
data=ConfigFieldDelete(field_name=field_name, config_type="general_settings"),
|
||||
user_api_key_dict=admin,
|
||||
)
|
||||
|
||||
assert (refused.value.status_code, refused.value.detail) == (
|
||||
400,
|
||||
{
|
||||
"error": "general_settings is stored in the database as something other than a JSON object, so no field "
|
||||
"can be removed from it"
|
||||
},
|
||||
)
|
||||
fake_prisma.db.litellm_config.upsert.assert_not_awaited()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_delete_config_general_settings_refuses_a_key_neither_managed_nor_stored(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
from litellm.proxy._types import ConfigFieldDelete
|
||||
from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings
|
||||
|
||||
pc: Final = ProxyConfig()
|
||||
pc._load_yaml_settings_stores({"general_settings": {}})
|
||||
fake_prisma: Final = _fake_prisma_with_config({"store_prompts_in_spend_logs": True})
|
||||
monkeypatch.setattr(proxy_server_module, "proxy_config", pc)
|
||||
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
|
||||
|
||||
admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
|
||||
with pytest.raises(HTTPException) as refused:
|
||||
await delete_config_general_settings(
|
||||
data=ConfigFieldDelete(field_name="enforce_user_param", config_type="general_settings"),
|
||||
user_api_key_dict=admin,
|
||||
)
|
||||
|
||||
assert refused.value.status_code == 400
|
||||
fake_prisma.db.litellm_config.upsert.assert_not_awaited()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_config_field_info_reports_the_declared_value_of_a_config_owned_secret(monkeypatch):
|
||||
from litellm.proxy.proxy_server import ProxyConfig, get_config_general_settings
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue