Spaces:
Running
Running
Download src/free_claude_code/config/admin/persistence.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 10.7 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/config/admin/persistence.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/src/free_claude_code/config/admin/persistence.py
-
curl -L -o persistence.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/config/admin/persistence.py
10.7 kB
| from __future__ import annotations | |
| """Sparse managed-config validation, preview, and atomic persistence.""" | |
| from collections.abc import Mapping | |
| from dataclasses import dataclass, field | |
| from pathlib import Path | |
| from free_claude_code.config.api_keys import ApiKeyList, api_key_values, first_api_key | |
| from free_claude_code.config.env_files import ( | |
| FCC_CONFIG_SCHEMA_ENV, | |
| ) | |
| from free_claude_code.config.env_migrations import ( | |
| CONFIG_SCHEMA_VERSION, | |
| recognized_env_keys, | |
| render_managed_config, | |
| ) | |
| from free_claude_code.config.errors import ConfigConflictError | |
| from free_claude_code.config.loader import ManagedConfigSnapshot | |
| from free_claude_code.config.model_refs import normalize_retired_model_settings | |
| from free_claude_code.config.provider_proxies import invalid_provider_proxy_keys | |
| from free_claude_code.config.settings import Settings | |
| from free_claude_code.core.json_types import JsonObject | |
| from .credentials import ( | |
| CredentialEditError, | |
| CredentialRowError, | |
| CredentialSubmission, | |
| resolve_credential_edit, | |
| ) | |
| from .custom_providers import CustomProviderMutation, merge_custom_provider | |
| from .manifest import FIELD_BY_KEY, FIELDS | |
| from .state import ConfigInputValue | |
| from .validation import settings_from_values | |
| from .values import MASKED_SECRET, is_locked_source, load_value_state, normalize_for_env | |
| _PROVIDER_PROXY_ERROR = ( | |
| "must be a proxy URL with a supported scheme and host " | |
| "(for example http://127.0.0.1:8080 or socks5://127.0.0.1:1080)" | |
| ) | |
| class PreparedAdminUpdate: | |
| """Validated Admin update ready for an atomic managed-file commit.""" | |
| target_values: dict[str, str] = field(repr=False) | |
| settings: Settings | None | |
| errors: tuple[str, ...] | |
| pending_fields: tuple[str, ...] | |
| path: Path | |
| expected: ManagedConfigSnapshot = field(repr=False) | |
| changed_keys: tuple[str, ...] = () | |
| custom_provider_id: str | None = None | |
| credential_submissions: tuple[CredentialSubmission, ...] = () | |
| credential_row_errors: tuple[CredentialRowError, ...] = () | |
| def valid(self) -> bool: | |
| return self.settings is not None and not self.errors | |
| def validation_response(self) -> JsonObject: | |
| return { | |
| "valid": self.valid, | |
| "errors": list(self.errors), | |
| "credential_row_errors": [ | |
| error.public() for error in self.credential_row_errors | |
| ], | |
| "env_preview": render_managed_config( | |
| self.target_values, | |
| mask_secrets=True, | |
| ), | |
| } | |
| def applied_response(self) -> JsonObject: | |
| if not self.valid: | |
| return self.validation_response() | { | |
| "applied": False, | |
| "pending_fields": [], | |
| } | |
| return { | |
| "custom_provider_id": self.custom_provider_id, | |
| "applied": True, | |
| "valid": True, | |
| "errors": [], | |
| "env_preview": render_managed_config( | |
| self.target_values, | |
| mask_secrets=True, | |
| ), | |
| "path": str(self.path), | |
| "pending_fields": list(self.pending_fields), | |
| } | |
| def target_values_with_updates( | |
| updates: Mapping[str, ConfigInputValue], | |
| snapshot: ManagedConfigSnapshot, | |
| ) -> dict[str, str]: | |
| """Return sparse managed state after applying valid partial-update semantics.""" | |
| state = load_value_state(snapshot) | |
| values = dict(snapshot.managed) | |
| known = recognized_env_keys() | |
| for key in tuple(values): | |
| if key in known and key != FCC_CONFIG_SCHEMA_ENV and not values[key].strip(): | |
| values.pop(key) | |
| for key, submitted in updates.items(): | |
| field = FIELD_BY_KEY.get(key) | |
| if field is None or is_locked_source(state[key].source): | |
| continue | |
| if field.secret and ( | |
| submitted == MASKED_SECRET | |
| or (isinstance(submitted, str) and not submitted.strip()) | |
| ): | |
| continue | |
| value = normalize_for_env(submitted, key=key) | |
| if value is None or (field.nullable and not value): | |
| values.pop(key, None) | |
| else: | |
| values[key] = value | |
| values[FCC_CONFIG_SCHEMA_ENV] = CONFIG_SCHEMA_VERSION | |
| return normalize_retired_model_settings(values, preserve_empty_overrides=False) | |
| def pending_restart_fields(active: Settings, prospective: Settings) -> tuple[str, ...]: | |
| """Compare saved intent with the settings actually used by running resources.""" | |
| voice_credentials = { | |
| _active_voice_credential(active), | |
| _active_voice_credential(prospective), | |
| } | |
| pending = [] | |
| for spec in FIELDS: | |
| if spec.settings_attr is None or not ( | |
| spec.restart_required | |
| or spec.session_sensitive | |
| or spec.key in voice_credentials | |
| ): | |
| continue | |
| before, after = ( | |
| getattr(active, spec.settings_attr), | |
| getattr(prospective, spec.settings_attr), | |
| ) | |
| if spec.field_type == "api_key_list": | |
| before, after = first_api_key(before), first_api_key(after) | |
| if before != after: | |
| pending.append(spec.key) | |
| return tuple(pending) | |
| def prepare_admin_update( | |
| updates: Mapping[str, ConfigInputValue], | |
| snapshot: ManagedConfigSnapshot, | |
| active_settings: Settings, | |
| custom_provider: CustomProviderMutation | None = None, | |
| *, | |
| revision_key: bytes, | |
| ) -> PreparedAdminUpdate: | |
| """Validate an update and construct its prospective Settings snapshot.""" | |
| resolved = dict(updates) | |
| row_errors: list[CredentialRowError] = [] | |
| credential_errors: list[str] = [] | |
| submissions: list[CredentialSubmission] = [] | |
| for key, submitted in updates.items(): | |
| spec = FIELD_BY_KEY.get(key) | |
| if spec is None or spec.field_type != "api_key_list": | |
| continue | |
| assert spec.settings_attr is not None | |
| try: | |
| keys = resolve_credential_edit( | |
| key, | |
| getattr(snapshot.settings, spec.settings_attr), | |
| snapshot.sources[spec.settings_attr].value, | |
| submitted, | |
| revision_key, | |
| key=key, | |
| ) | |
| except ConfigConflictError: | |
| raise | |
| except ValueError as exc: | |
| resolved.pop(key) | |
| credential_errors.append(str(exc)) | |
| if isinstance(exc, CredentialEditError): | |
| row_errors.extend(exc.row_errors) | |
| else: | |
| resolved[key] = api_key_values(keys) | |
| submissions.append(CredentialSubmission(key, keys)) | |
| custom_keys: ApiKeyList | None = None | |
| if ( | |
| custom_provider is not None | |
| and custom_provider.action != "delete" | |
| and "api_keys" in custom_provider.values | |
| ): | |
| changes = dict(custom_provider.values) | |
| submitted = changes.pop("api_keys") | |
| definition = snapshot.settings.custom_provider( | |
| custom_provider.provider_id or "" | |
| ) | |
| try: | |
| custom_keys = resolve_credential_edit( | |
| "custom:" + (custom_provider.provider_id or "new"), | |
| definition.api_keys if definition else (), | |
| snapshot.sources["custom_providers"].value, | |
| submitted, | |
| revision_key, | |
| key="api_keys", | |
| provider_id=custom_provider.provider_id, | |
| new_owner=custom_provider.action == "create", | |
| ) | |
| except ConfigConflictError: | |
| raise | |
| except ValueError as exc: | |
| credential_errors.append(str(exc)) | |
| if isinstance(exc, CredentialEditError): | |
| row_errors.extend(exc.row_errors) | |
| else: | |
| changes["api_keys"] = api_key_values(custom_keys) | |
| custom_provider = custom_provider.model_copy(update={"values": changes}) | |
| update_errors = (*credential_errors, *_update_protocol_errors(resolved)) | |
| target_values = target_values_with_updates(resolved, snapshot) | |
| custom_id = None | |
| if custom_provider is not None: | |
| try: | |
| custom_id = merge_custom_provider(target_values, snapshot, custom_provider) | |
| except ValueError as exc: | |
| update_errors = (*update_errors, str(exc)) | |
| if custom_keys is not None: | |
| submissions.append(CredentialSubmission("api_keys", custom_keys, custom_id)) | |
| settings, settings_errors = settings_from_values(target_values, snapshot.process) | |
| errors = ( | |
| *update_errors, | |
| *settings_errors, | |
| *_provider_proxy_errors(target_values), | |
| ) | |
| pending_fields = ( | |
| pending_restart_fields(active_settings, settings) | |
| if settings is not None and not errors | |
| else () | |
| ) | |
| state = load_value_state(snapshot) | |
| changed_keys = tuple( | |
| key | |
| for key, submitted in resolved.items() | |
| if key in FIELD_BY_KEY | |
| and not is_locked_source(state[key].source) | |
| and (value := normalize_for_env(submitted, key=key)) | |
| and value != MASKED_SECRET | |
| and value != state[key].value | |
| and key in target_values | |
| and target_values[key] == value | |
| ) | |
| return PreparedAdminUpdate( | |
| target_values=target_values, | |
| settings=settings, | |
| errors=errors, | |
| pending_fields=pending_fields, | |
| path=snapshot.path, | |
| expected=snapshot, | |
| changed_keys=changed_keys, | |
| custom_provider_id=custom_id, | |
| credential_submissions=tuple(submissions), | |
| credential_row_errors=tuple(row_errors), | |
| ) | |
| def _update_protocol_errors( | |
| updates: Mapping[str, ConfigInputValue], | |
| ) -> tuple[str, ...]: | |
| errors: list[str] = [] | |
| for key, submitted in updates.items(): | |
| field = FIELD_BY_KEY.get(key) | |
| if field is None or (field.secret and submitted == MASKED_SECRET): | |
| continue | |
| if submitted is None and not field.nullable: | |
| errors.append(f"{key}: this setting cannot be removed") | |
| continue | |
| if ( | |
| not field.secret | |
| and isinstance(submitted, str) | |
| and not submitted.strip() | |
| and not field.nullable | |
| ): | |
| errors.append(f"{key}: this setting cannot be blank") | |
| return tuple(errors) | |
| def _provider_proxy_errors(values: Mapping[str, str]) -> tuple[str, ...]: | |
| return tuple( | |
| f"{key}: {_PROVIDER_PROXY_ERROR}" for key in invalid_provider_proxy_keys(values) | |
| ) | |
| def _active_voice_credential(settings: Settings) -> str | None: | |
| if not settings.voice_note_enabled: | |
| return None | |
| if settings.whisper_device == "nvidia_nim": | |
| return "NVIDIA_NIM_API_KEY" | |
| return "HUGGINGFACE_API_KEY" | |