Buckets:
# backend/session.py
import os
import json
import traceback
import datetime
import threading
from pathlib import Path
from typing import Dict, Optional, Any, cast, Callable, Tuple
from urllib.parse import urlparse
from fastapi import HTTPException, Depends, status
from sqlalchemy.orm import Session, joinedload, object_session
from werkzeug.utils import secure_filename
from ascii_colors import trace_exception, ASCIIColors
from backend.db import get_db
from backend.db.models.user import User as DBUser
from backend.db.models.service import MCP as DBMCP, App as DBApp
from backend.db.models.datastore import DataStore as DBDataStore, SharedDataStoreLink as DBSharedDataStoreLink
from backend.db.models.personality import Personality as DBPersonality
from backend.db.models.config import (
GlobalConfig, LLMBinding as DBLLMBinding, TTIBinding as DBTTIBinding,
TTSBinding as DBTTSBinding, STTBinding as DBSTTBinding
)
from lollms_client import LollmsClient
from backend.models.user import UserAuthDetails
from backend.models.auth import TokenData
from backend.security import oauth2_scheme, decode_main_access_token
from backend.config import (
APP_DATA_DIR,
SAFE_STORE_DEFAULTS,
USERS_DIR_NAME,
TEMP_UPLOADS_DIR_NAME,
DISCUSSION_ASSETS_DIR_NAME,
DM_ASSETS_DIR_NAME,
DATASTORES_DIR_NAME,
VOICES_DIR_NAME,
IMAGES_DIR_NAME,
NOTEBOOK_ASSETS_DIR_NAME
)
from backend.settings import settings
from backend.security import create_access_token
try:
import safe_store
except ImportError:
safe_store = None
# Global In-Memory Session Cache
user_sessions: Dict[str, Dict[str, Any]] = {}
# Authentication Cache to prevent DB bombardment during request bursts
_token_user_cache: Dict[str, tuple] = {}
_token_cache_lock = threading.Lock()
TOKEN_CACHE_TTL = 10 # seconds
# Global Client Registry to prevent file descriptor exhaustion
_global_client_registry: Dict[str, LollmsClient] = {}
_registry_lock = threading.Lock()
# Locks to prevent race conditions during concurrent requests
_session_init_lock = threading.Lock()
_client_build_locks: Dict[str, threading.Lock] = {}
_client_build_locks_lock = threading.Lock()
def ensure_bool(value, default=False):
if isinstance(value, bool):
return value
elif isinstance(value, str):
try:
return value.lower() in ("true", "yes", "1")
except Exception:
return default
else:
return default
def get_user_by_username(db: Session, username: str) -> Optional[DBUser]:
return db.query(DBUser).filter(DBUser.username == username).first()
async def get_current_db_user_from_token(
token: str = Depends(oauth2_scheme),
db: Session = Depends(get_db)
) -> DBUser:
now = datetime.datetime.now(datetime.timezone.utc)
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
payload = decode_main_access_token(token)
if payload is None:
raise credentials_exception
username: str = payload.get("sub")
if username is None:
raise credentials_exception
with _token_cache_lock:
if token in _token_user_cache:
cached_user, expiry = _token_user_cache[token]
if now < expiry:
merged_user = db.merge(cached_user, load=False)
token_iat = payload.get("iat")
pwd_changed = merged_user.password_changed_at
if pwd_changed and token_iat is not None:
pwd_changed_ts = pwd_changed.replace(tzinfo=datetime.timezone.utc).timestamp() if pwd_changed.tzinfo is None else pwd_changed.timestamp()
if (token_iat + 1) < pwd_changed_ts:
del _token_user_cache[token]
raise credentials_exception
return merged_user
else:
del _token_user_cache[token]
try:
user = db.query(DBUser).filter(DBUser.username == username).first()
if user is None:
raise credentials_exception
token_iat = payload.get("iat")
if user.password_changed_at is not None and token_iat is not None:
pwd_changed = user.password_changed_at
pwd_changed_ts = pwd_changed.replace(tzinfo=datetime.timezone.utc).timestamp() if pwd_changed.tzinfo is None else pwd_changed.timestamp()
if (token_iat + 1) < pwd_changed_ts:
raise credentials_exception
try:
last_act = user.last_activity_at
if last_act is None:
user.last_activity_at = now
db.commit()
db.refresh(user)
elif isinstance(last_act, datetime.datetime):
last_activity_aware = last_act.replace(tzinfo=datetime.timezone.utc) if last_act.tzinfo is None else last_act
if (now - last_activity_aware) > datetime.timedelta(seconds=60):
user.last_activity_at = now
db.commit()
db.refresh(user)
except Exception:
db.rollback()
with _token_cache_lock:
_token_user_cache[token] = (user, now + datetime.timedelta(seconds=TOKEN_CACHE_TTL))
if len(_token_user_cache) > 1000:
_token_user_cache.clear()
return user
except HTTPException:
raise
except Exception as e:
trace_exception(e)
raise credentials_exception
def get_current_active_user(db_user: DBUser = Depends(get_current_db_user_from_token)) -> UserAuthDetails:
if not db_user.is_active:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="User account is inactive.")
is_maintenance = settings.get("maintenance_mode", False)
if is_maintenance and not db_user.is_admin:
msg = settings.get("maintenance_message", "System under maintenance.")
raise HTTPException(
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
detail=msg
)
username = db_user.username
db = object_session(db_user)
db_was_created = False
if not db:
db = next(get_db())
db_user = db.merge(db_user)
db_was_created = True
try:
session_ui_level = db_user.user_ui_level
if db_user.is_admin and session_ui_level != 4:
session_ui_level = 4
if username not in user_sessions:
with _session_init_lock:
if username not in user_sessions:
session_llm_params = {
"temperature": db_user.llm_temperature,
"top_k": db_user.llm_top_k, "top_p": db_user.llm_top_p,
"repeat_penalty": db_user.llm_repeat_penalty, "repeat_last_n": db_user.llm_repeat_last_n,
"put_thoughts_in_context": db_user.put_thoughts_in_context
}
user_sessions[username] = {
"safe_store_instances": {}, "discussions": {},
"active_vectorizer": db_user.safe_store_vectorizer or SAFE_STORE_DEFAULTS.get("global_default_vectorizer"),
"lollms_model_name": db_user.lollms_model_name,
"llm_params": {k: v for k, v in session_llm_params.items() if v is not None},
"active_personality_id": db_user.active_personality_id,
}
user_model_full = db_user.lollms_model_name
force_model_mode = settings.get("force_model_mode", "disabled")
forced_model = settings.get("force_model_name")
if force_model_mode == "force_always" and forced_model:
user_model_full = forced_model
session = user_sessions[username]
if session.get("lollms_model_name") != user_model_full:
session["lollms_model_name"] = user_model_full
llm_settings_overridden = False
effective_llm_params = {
"llm_temperature": db_user.llm_temperature,
"llm_top_k": db_user.llm_top_k,
"llm_top_p": db_user.llm_top_p,
"llm_repeat_penalty": db_user.llm_repeat_penalty,
"llm_repeat_last_n": db_user.llm_repeat_last_n,
"put_thoughts_in_context": db_user.put_thoughts_in_context,
"reasoning_activation": db_user.reasoning_activation,
"reasoning_effort": db_user.reasoning_effort,
"reasoning_summary": db_user.reasoning_summary
}
if user_model_full and '/' in user_model_full:
binding_alias, model_name = user_model_full.split('/', 1)
binding = db.query(DBLLMBinding).filter(DBLLMBinding.alias == binding_alias).first()
if binding and binding.model_aliases:
if isinstance(binding.model_aliases, str):
try:
binding.model_aliases = json.loads(binding.model_aliases)
except Exception as e:
binding.model_aliases = {}
alias_info = binding.model_aliases.get(model_name)
if alias_info and not alias_info.get('allow_parameters_override', True):
llm_settings_overridden = True
param_map = {"temperature": "llm_temperature", "top_k": "llm_top_k", "top_p": "llm_top_p", "repeat_penalty": "llm_repeat_penalty", "repeat_last_n": "llm_repeat_last_n", "reasoning_activation": "reasoning_activation", "reasoning_effort": "reasoning_effort", "reasoning_summary": "reasoning_summary"}
for alias_key, user_key in param_map.items():
if alias_key in alias_info and alias_info[alias_key] is not None:
effective_llm_params[user_key] = alias_info[alias_key]
lc = get_user_lollms_client(username)
ai_name_for_user = getattr(lc, "ai_name", "assistant")
is_api_service_enabled = ensure_bool(settings.get("openai_api_service_enabled", False), False)
is_api_require_key = ensure_bool(settings.get("openai_api_require_key", True), True)
is_ollama_service_enabled = ensure_bool(settings.get("ollama_service_enabled", False), False)
is_ollama_require_key = ensure_bool(settings.get("ollama_require_key", True), True)
latex_builder_enabled = ensure_bool(settings.get("latex_builder_enabled", False), False)
allow_user_chunking_config = ensure_bool(settings.get("allow_user_chunking_config", True), True)
default_chunk_size = settings.get("default_chunk_size", 2048)
default_chunk_overlap = settings.get("default_chunk_overlap", 256)
force_rag_mode = settings.get("force_rag_settings_mode", "disabled")
rag_settings_forced = False
effective_rag_top_k = db_user.rag_top_k
effective_max_rag_len = db_user.max_rag_len
effective_rag_n_hops = db_user.rag_n_hops
effective_rag_min_sim_percent = db_user.rag_min_sim_percent
effective_rag_use_graph = db_user.rag_use_graph
effective_rag_graph_response_type = db_user.rag_graph_response_type
effective_rag_retrieval_mode = db_user.rag_retrieval_mode or "hybrid"
effective_rag_dense_weight = db_user.rag_dense_weight if db_user.rag_dense_weight is not None else 0.5
effective_rag_bm25_weight = db_user.rag_bm25_weight if db_user.rag_bm25_weight is not None else 0.5
effective_rag_graph_weight = db_user.rag_graph_weight if db_user.rag_graph_weight is not None else 0.3
effective_rag_rrf_k = db_user.rag_rrf_k or 60
effective_default_rag_chunk_size = db_user.default_rag_chunk_size
effective_default_rag_chunk_overlap = db_user.default_rag_chunk_overlap
effective_safe_store_vectorizer = user_sessions[username].get("active_vectorizer")
if force_rag_mode == "force_always":
rag_settings_forced = True
allow_user_chunking_config = False
forced_vec = settings.get("force_rag_vectorizer")
if forced_vec:
effective_safe_store_vectorizer = forced_vec
effective_default_rag_chunk_size = settings.get("force_rag_chunk_size", 2048)
effective_default_rag_chunk_overlap = settings.get("force_rag_chunk_overlap", 256)
default_chunk_size = effective_default_rag_chunk_size
default_chunk_overlap = effective_default_rag_chunk_overlap
effective_rag_top_k = settings.get("force_rag_top_k", 10)
effective_max_rag_len = settings.get("force_rag_max_rag_len", 80000)
effective_rag_n_hops = settings.get("force_rag_n_hops", 0)
effective_rag_min_sim_percent = float(settings.get("force_rag_min_sim_percent", 50.0))
effective_rag_retrieval_mode = settings.get("force_rag_retrieval_mode", "hybrid")
effective_rag_dense_weight = float(settings.get("force_rag_dense_weight", 0.5))
effective_rag_bm25_weight = float(settings.get("force_rag_bm25_weight", 0.5))
effective_rag_rrf_k = int(settings.get("force_rag_rrf_k", 60))
effective_rag_use_graph = ensure_bool(settings.get("force_rag_use_graph", False), False)
effective_rag_graph_response_type = settings.get("force_rag_graph_response_type", "chunks_summary")
return UserAuthDetails(
id=db_user.id, username=username, is_admin=db_user.is_admin, is_moderator=(db_user.is_admin or db_user.is_moderator), is_active=db_user.is_active,
icon=db_user.icon, first_name=db_user.first_name, family_name=db_user.family_name, email=db_user.email,
birth_date=db_user.birth_date, receive_notification_emails=db_user.receive_notification_emails,
is_searchable=db_user.is_searchable, first_login_done=db_user.first_login_done,
data_zone=db_user.data_zone,
lollms_model_name=db_user.lollms_model_name,
tti_binding_model_name=db_user.tti_binding_model_name,
iti_binding_model_name=db_user.iti_binding_model_name,
tti_models_config=db_user.tti_models_config,
tts_binding_model_name=db_user.tts_binding_model_name,
tts_models_config=db_user.tts_models_config,
stt_binding_model_name=db_user.stt_binding_model_name,
stt_models_config=db_user.stt_models_config,
safe_store_vectorizer=effective_safe_store_vectorizer,
active_personality_id=user_sessions[username].get("active_personality_id"),
active_voice_id=db_user.active_voice_id,
last_discussion_id=db_user.last_discussion_id,
lollms_client_ai_name=ai_name_for_user,
**effective_llm_params,
rag_top_k=effective_rag_top_k,
max_rag_len=effective_max_rag_len,
rag_n_hops=effective_rag_n_hops,
rag_min_sim_percent=effective_rag_min_sim_percent,
rag_use_graph=effective_rag_use_graph,
rag_graph_response_type=effective_rag_graph_response_type,
rag_retrieval_mode=effective_rag_retrieval_mode,
rag_dense_weight=effective_rag_dense_weight,
rag_bm25_weight=effective_rag_bm25_weight,
rag_graph_weight=effective_rag_graph_weight,
rag_rrf_k=effective_rag_rrf_k,
default_rag_chunk_size=effective_default_rag_chunk_size,
default_rag_chunk_overlap=effective_default_rag_chunk_overlap,
default_rag_metadata_mode=db_user.default_rag_metadata_mode,
rag_settings_forced=rag_settings_forced,
auto_title=db_user.auto_title,
user_ui_level=session_ui_level if isinstance(session_ui_level, int) else int(session_ui_level) if isinstance(session_ui_level, str) else 0, chat_active=db_user.chat_active, first_page=db_user.first_page,
ai_response_language=db_user.ai_response_language,
force_ai_response_language=db_user.force_ai_response_language,
fun_mode=db_user.fun_mode,
show_token_counter=db_user.show_token_counter,
openai_api_service_enabled=is_api_service_enabled,
openai_api_require_key=is_api_require_key,
ollama_service_enabled=is_ollama_service_enabled,
ollama_require_key=is_ollama_require_key,
include_memory_date_in_context=db_user.include_memory_date_in_context,
llm_settings_overridden=llm_settings_overridden,
tti_model_forced=False,
iti_model_forced=False,
latex_builder_enabled=latex_builder_enabled,
coding_style_constraints=db_user.coding_style_constraints,
programming_language_preferences=db_user.programming_language_preferences,
tell_llm_os=db_user.tell_llm_os,
share_dynamic_info_with_llm=db_user.share_dynamic_info_with_llm,
message_font_size=db_user.message_font_size,
allow_user_chunking_config=allow_user_chunking_config,
default_chunk_size=default_chunk_size,
default_chunk_overlap=default_chunk_overlap,
image_studio_prompt=db_user.image_studio_prompt,
image_studio_negative_prompt=db_user.image_studio_negative_prompt,
image_studio_image_size=db_user.image_studio_image_size,
image_studio_n_images=db_user.image_studio_n_images,
image_studio_seed=db_user.image_studio_seed or -1,
image_studio_generation_params=db_user.image_studio_generation_params,
image_generation_enabled=db_user.image_generation_enabled,
image_generation_system_prompt=db_user.image_generation_system_prompt,
image_annotation_enabled=db_user.image_annotation_enabled,
image_editing_enabled=db_user.image_editing_enabled,
inline_widgets_enabled=db_user.inline_widgets_enabled,
slide_maker_enabled=db_user.slide_maker_enabled,
activate_generated_images=db_user.activate_generated_images,
note_generation_enabled=db_user.note_generation_enabled,
memory_enabled=db_user.memory_enabled,
auto_memory_enabled=db_user.auto_memory_enabled,
skills_library_enabled=db_user.skills_library_enabled,
skills_building_enabled=db_user.skills_building_enabled,
form_building_enabled=db_user.form_building_enabled,
preferred_name=db_user.preferred_name,
user_personal_info=db_user.user_personal_info,
share_personal_info_with_llm=db_user.share_personal_info_with_llm,
max_image_width=db_user.max_image_width,
max_image_height=db_user.max_image_height,
compress_images=db_user.compress_images,
image_compression_quality=db_user.image_compression_quality,
herd_mode_enabled=db_user.herd_mode_enabled,
herd_participants=db_user.herd_participants or [],
herd_precode_participants=db_user.herd_precode_participants or [],
herd_postcode_participants=db_user.herd_postcode_participants or [],
herd_rounds=db_user.herd_rounds,
herd_dynamic_mode=db_user.herd_dynamic_mode,
herd_model_pool=db_user.herd_model_pool or [],
google_api_key=db_user.google_api_key,
google_cse_id=db_user.google_cse_id,
web_search_enabled=db_user.web_search_enabled,
web_search_providers=db_user.web_search_providers or [],
web_search_deep_analysis=db_user.web_search_deep_analysis,
street_view_enabled=db_user.street_view_enabled,
scheduler_enabled=db_user.scheduler_enabled,
google_drive_enabled=db_user.google_drive_enabled,
google_calendar_enabled=db_user.google_calendar_enabled,
google_gmail_enabled=db_user.google_gmail_enabled
)
finally:
if db_was_created:
db.close()
def get_current_admin_user(current_user: UserAuthDetails = Depends(get_current_active_user)) -> UserAuthDetails:
if not current_user.is_admin:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Administrator privileges required.")
return current_user
def load_mcps(username):
session = user_sessions.get(username)
is_temp_session = not session
servers_infos = {}
db_for_mcp = next(get_db())
try:
app_mcps = db_for_mcp.query(DBApp).options(joinedload(DBApp.owner)).filter(DBApp.app_metadata['item_type'].as_string() == 'mcp').all()
system_mcps = db_for_mcp.query(DBMCP).filter(DBMCP.type == 'system', DBMCP.active == True).all()
user_db = db_for_mcp.query(DBUser).filter(DBUser.username == username).first()
personal_mcps = []
access_token = None
if user_db:
if session and not is_temp_session:
session["access_token"] = create_access_token(data={"sub": user_db.username})
access_token = session.get("access_token")
else:
access_token = create_access_token(data={"sub": user_db.username})
personal_mcps = [mcp for mcp in user_db.personal_mcps if mcp.active]
all_active_mcps = app_mcps + system_mcps + personal_mcps
for mcp in all_active_mcps:
try:
if not mcp.url: continue
mcp_base_url = mcp.url.rstrip('/')
parsed = urlparse(mcp_base_url)
if mcp_base_url.endswith('/mcp'):
mcp_full_url = mcp_base_url
elif parsed.path and parsed.path != '/':
mcp_full_url = mcp_base_url
else:
mcp_full_url = f"{mcp_base_url}/mcp"
server_info = {"server_url": mcp_full_url}
if mcp.authentication_type == "lollms_chat_auth" and access_token:
server_info["auth_config"] = { "type": "bearer", "token": access_token }
elif mcp.authentication_type == "bearer":
server_info["auth_config"] = { "type": "bearer", "token": mcp.authentication_key }
elif mcp.authentication_type == "api_key":
key = mcp.authentication_key
header = "X-API-Key"
if key and key.strip().startswith('{'):
try:
data = json.loads(key)
if isinstance(data, dict):
key = data.get("key", "")
header = data.get("header_name", "X-API-Key")
except Exception as e:
print(f"Warning: Failed to parse API key JSON for {mcp.name}: {e}")
server_info["auth_config"] = {
"type": "api_key",
"key": key,
"header_name": header
}
servers_infos[mcp.name] = server_info
except Exception as e:
trace_exception(e)
finally:
db_for_mcp.close()
return servers_infos
def invalidate_user_mcp_cache(username: str):
if username in user_sessions:
session = user_sessions[username]
if 'tools_cache' in session:
del session['tools_cache']
if 'servers_infos' in session:
del session['servers_infos']
session.pop("lollms_clients_cache", None)
print(f"INFO: Fully invalidated MCP caches for user: {username}")
def reload_lollms_client_mcp(username: str):
invalidate_user_mcp_cache(username)
def get_user_lollms_client(username: str, binding_alias_override: Optional[str] = None, load_mcp: bool = True) -> LollmsClient:
client = build_lollms_client_from_params(username, binding_alias_override, load_mcp=load_mcp)
if username in user_sessions:
clients_cache = user_sessions[username].setdefault("lollms_clients_cache", {})
cache_key = binding_alias_override or "default"
if not load_mcp:
cache_key += "_no_mcp"
clients_cache[cache_key] = client
return client
def _build_universal_profiles_for_modality(
db: Session,
binding_model_cls: Any,
active_binding_alias: Optional[str],
active_model_name: Optional[str],
user_overrides: Dict[str, Any],
forced_ctx_size: Optional[int] = None
) -> Tuple[Dict[str, Any], Dict[str, Any], Optional[str]]:
all_bindings = db.query(binding_model_cls).filter(binding_model_cls.is_active == True).all()
binding_profiles = {}
model_profiles = {}
default_model_profile_name = None
# First pass: Build concrete binding profiles & regular model profiles
for binding in all_bindings:
b_config = binding.config.copy() if binding.config else {}
is_binding_default = (binding.alias == active_binding_alias)
binding_profiles[binding.alias] = {
"binding_name": binding.name,
"binding_config": b_config,
"is_default": is_binding_default
}
aliases = binding.model_aliases or {}
if isinstance(aliases, str):
try: aliases = json.loads(aliases)
except Exception: aliases = {}
for orig_name, alias_data in aliases.items():
if not isinstance(alias_data, dict):
alias_data = {"title": str(alias_data)}
cfg = alias_data.get('alias', {}) if 'alias' in alias_data else alias_data
prof_name = f"{binding.alias}/{orig_name}"
is_model_default = is_binding_default and (orig_name == active_model_name or cfg.get('title') == active_model_name)
if is_model_default:
default_model_profile_name = prof_name
raw_ctx = forced_ctx_size or cfg.get('forced_context_size') or cfg.get('ctx_size')
effective_ctx = None
if raw_ctx is not None:
try:
parsed_ctx = int(raw_ctx)
if parsed_ctx > 1:
effective_ctx = parsed_ctx
except (ValueError, TypeError):
effective_ctx = None
target_model = cfg.get('model_name') or orig_name
profile_entry = {
"binding_profile_name": binding.alias,
"model_name": target_model,
"title": cfg.get('title') or orig_name,
"description": cfg.get('description', ''),
"vision_enabled": cfg.get('vision_enabled', cfg.get('has_vision', False)),
"has_vision": cfg.get('has_vision', cfg.get('vision_enabled', False)),
"forced_context_size": effective_ctx,
"ctx_size": effective_ctx,
"temperature": cfg.get('temperature'),
"top_k": cfg.get('top_k'),
"top_p": cfg.get('top_p'),
"repeat_penalty": cfg.get('repeat_penalty'),
"repeat_last_n": cfg.get('repeat_last_n'),
"reasoning_activation": cfg.get('reasoning_activation', False),
"reasoning_effort": cfg.get('reasoning_effort'),
"reasoning_summary": cfg.get('reasoning_summary', False),
"allow_parameters_override": cfg.get('allow_parameters_override', True),
"icon": cfg.get('icon'),
"routing_config": cfg.get('routing_config', {
"description": cfg.get('description') or cfg.get('title') or orig_name,
"complexity_tier": 2,
"cost_per_1k_tokens": 0.0,
"avg_latency_ms": 200,
"priority": 1
}),
"vlm_model_profile": cfg.get('vlm_model_profile'),
"selected_model_profiles": cfg.get('selected_model_profiles', []),
"routing_strategy": cfg.get('routing_strategy', 'balanced'),
"is_default": is_model_default
}
if profile_entry["allow_parameters_override"] and user_overrides:
for k, v in user_overrides.items():
if v is not None:
profile_entry[k] = v
model_profiles[prof_name] = profile_entry
default_model = binding.default_model_name
if default_model and f"{binding.alias}/{default_model}" not in model_profiles:
prof_name = f"{binding.alias}/{default_model}"
is_model_default = is_binding_default and (default_model == active_model_name or active_model_name is None)
if is_model_default:
default_model_profile_name = prof_name
model_profiles[prof_name] = {
"binding_profile_name": binding.alias,
"model_name": default_model,
"title": default_model,
"description": f"Default model for {binding.alias}",
"vision_enabled": False,
"has_vision": False,
"forced_context_size": forced_ctx_size,
"ctx_size": forced_ctx_size,
"routing_config": {
"description": f"Default model {default_model}",
"complexity_tier": 2,
"cost_per_1k_tokens": 0.0,
"avg_latency_ms": 200,
"priority": 1
},
"is_default": is_model_default,
**user_overrides
}
# Second pass: Dynamically assemble Smart Router groups using member profiles
for binding in all_bindings:
if (binding.name == 'smart_router' or binding.alias == 'smart_router'):
aliases = binding.model_aliases or {}
if isinstance(aliases, str):
try: aliases = json.loads(aliases)
except Exception: aliases = {}
if not aliases:
aliases = {"auto": {"title": "Auto Smart Router", "routing_strategy": "balanced"}}
for group_key, group_data in aliases.items():
if not isinstance(group_data, dict):
group_data = {"title": str(group_data)}
cfg = group_data.get('alias', {}) if 'alias' in group_data else group_data
selected_profs = cfg.get('selected_model_profiles', [])
group_strategy = cfg.get('routing_strategy', 'balanced')
assembled_pool = {}
for p_id, p_info in model_profiles.items():
if p_info.get("binding_profile_name") == binding.alias:
continue
if not selected_profs or p_id in selected_profs:
parent_b = binding_profiles.get(p_info["binding_profile_name"], {})
assembled_pool[p_id] = {
"binding_name": parent_b.get("binding_name", "openai"),
"binding_config": {
**(parent_b.get("binding_config", {})),
"model_name": p_info["model_name"]
},
"vision_enabled": p_info.get("vision_enabled", False),
"routing_profile": p_info.get("routing_config", {
"description": p_info.get("description") or p_info.get("title"),
"complexity_tier": 2,
"cost_per_1k_tokens": 0.0,
"avg_latency_ms": 200,
"priority": 1
})
}
smart_b_profile_name = f"{binding.alias}_group_{group_key}"
binding_profiles[smart_b_profile_name] = {
"binding_name": "smart_router",
"binding_config": {
"routing_strategy": group_strategy,
"model_profiles": assembled_pool
},
"is_default": (binding.alias == active_binding_alias and group_key == active_model_name)
}
prof_full_name = f"{binding.alias}/{group_key}"
is_group_default = (binding.alias == active_binding_alias and (group_key == active_model_name or active_model_name is None))
if is_group_default:
default_model_profile_name = prof_full_name
model_profiles[prof_full_name] = {
"binding_profile_name": smart_b_profile_name,
"model_name": group_key,
"title": cfg.get('title') or f"Smart Router ({group_key})",
"description": cfg.get('description', f"Auto-routing group with {len(assembled_pool)} models"),
"vision_enabled": True,
"has_vision": True,
"forced_context_size": forced_ctx_size or cfg.get('forced_context_size'),
"ctx_size": forced_ctx_size or cfg.get('forced_context_size'),
"selected_model_profiles": selected_profs,
"routing_strategy": group_strategy,
"is_default": is_group_default,
**user_overrides
}
return binding_profiles, model_profiles, default_model_profile_name
def build_lollms_client_from_params(
username: str,
binding_alias: Optional[str] = None,
model_name: Optional[str] = None,
llm_params: Optional[Dict[str, Any]] = None,
tti_binding_alias: Optional[str] = None,
tti_model_name: Optional[str] = None,
tti_params: Optional[Dict[str, Any]] = None,
tts_binding_alias: Optional[str] = None,
tts_model_name: Optional[str] = None,
tts_params: Optional[Dict[str, Any]] = None,
stt_binding_alias: Optional[str] = None,
stt_model_name: Optional[str] = None,
stt_params: Optional[Dict[str, Any]] = None,
load_llm: bool = True,
load_tti: bool = False,
load_tts: bool = False,
load_stt: bool = False,
load_mcp: bool = True,
callback: Optional[Callable] = None
) -> LollmsClient:
session = user_sessions.get(username)
if not session:
session = {
"safe_store_instances": {},
"discussions": {},
"llm_params": {},
}
db = next(get_db())
try:
user_db = db.query(DBUser).filter(DBUser.username == username).first()
if not user_db:
raise HTTPException(status_code=404, detail=f"User '{username}' not found.")
user_saved_params = {
"temperature": user_db.llm_temperature,
"top_k": user_db.llm_top_k, "top_p": user_db.llm_top_p,
"repeat_penalty": user_db.llm_repeat_penalty, "repeat_last_n": user_db.llm_repeat_last_n,
"put_thoughts_in_context": user_db.put_thoughts_in_context,
"reasoning_activation": user_db.reasoning_activation,
"reasoning_effort": user_db.reasoning_effort,
"reasoning_summary": user_db.reasoning_summary
}
user_session_params = session.get("llm_params", {})
final_user_params = {**{k: v for k, v in user_saved_params.items() if v is not None}, **user_session_params}
if llm_params:
final_user_params.update(llm_params)
force_model_mode = settings.get("force_model_mode", "disabled")
forced_ctx = None
if force_model_mode == "force_always":
forced_ctx = settings.get("force_context_size")
forced_model = settings.get("force_model_name")
if forced_model:
if '/' in forced_model:
binding_alias, model_name = forced_model.split('/', 1)
else:
binding_alias, model_name = None, forced_model
user_model_full = user_db.lollms_model_name or session.get("lollms_model_name") or settings.get("default_lollms_model_name")
target_binding_alias = binding_alias
target_model_name = model_name
if not target_binding_alias and user_model_full:
if '/' in user_model_full:
target_binding_alias, target_model_name = user_model_full.split('/', 1)
else:
try:
resolved_alias, resolved_model = resolve_model_name(db, user_model_full, fallback_to_default=True)
target_binding_alias = resolved_alias
if not target_model_name:
target_model_name = resolved_model
except Exception:
pass
if not target_binding_alias:
default_binding = db.query(DBLLMBinding).filter(DBLLMBinding.is_active == True).order_by(DBLLMBinding.id).first()
if default_binding:
target_binding_alias = default_binding.alias
if not target_model_name:
target_model_name = default_binding.default_model_name
llm_binding_profiles, llm_model_profiles, default_llm_prof = _build_universal_profiles_for_modality(
db=db,
binding_model_cls=DBLLMBinding,
active_binding_alias=target_binding_alias,
active_model_name=target_model_name,
user_overrides=final_user_params,
forced_ctx_size=forced_ctx
)
tti_binding_profiles, tti_model_profiles, _ = _build_universal_profiles_for_modality(
db=db,
binding_model_cls=DBTTIBinding,
active_binding_alias=tti_binding_alias or (user_db.tti_binding_model_name.split('/')[0] if user_db.tti_binding_model_name and '/' in user_db.tti_binding_model_name else None),
active_model_name=tti_model_name or (user_db.tti_binding_model_name.split('/', 1)[1] if user_db.tti_binding_model_name and '/' in user_db.tti_binding_model_name else None),
user_overrides=tti_params or {}
)
tts_binding_profiles, tts_model_profiles, _ = _build_universal_profiles_for_modality(
db=db,
binding_model_cls=DBTTSBinding,
active_binding_alias=tts_binding_alias or (user_db.tts_binding_model_name.split('/')[0] if user_db.tts_binding_model_name and '/' in user_db.tts_binding_model_name else None),
active_model_name=tts_model_name or (user_db.tts_binding_model_name.split('/', 1)[1] if user_db.tts_binding_model_name and '/' in user_db.tts_binding_model_name else None),
user_overrides=tts_params or {}
)
stt_binding_profiles, stt_model_profiles, _ = _build_universal_profiles_for_modality(
db=db,
binding_model_cls=DBSTTBinding,
active_binding_alias=stt_binding_alias or (user_db.stt_binding_model_name.split('/')[0] if user_db.stt_binding_model_name and '/' in user_db.stt_binding_model_name else None),
active_model_name=stt_model_name or (user_db.stt_binding_model_name.split('/', 1)[1] if user_db.stt_binding_model_name and '/' in user_db.stt_binding_model_name else None),
user_overrides=stt_params or {}
)
primary_binding = db.query(DBLLMBinding).filter(DBLLMBinding.alias == target_binding_alias, DBLLMBinding.is_active == True).first()
primary_config = primary_binding.config.copy() if primary_binding and primary_binding.config else {}
actual_model = target_model_name or (primary_binding.default_model_name if primary_binding else "")
found_alias_ctx = None
if primary_binding and primary_binding.model_aliases:
aliases_map = primary_binding.model_aliases
if isinstance(aliases_map, str):
try: aliases_map = json.loads(aliases_map)
except Exception: aliases_map = {}
if isinstance(aliases_map, dict):
alias_cfg = None
if target_model_name in aliases_map:
alias_item = aliases_map[target_model_name]
alias_cfg = alias_item.get('alias', {}) if isinstance(alias_item, dict) and 'alias' in alias_item else (alias_item if isinstance(alias_item, dict) else {})
else:
for orig_k, a_val in aliases_map.items():
a_dict = a_val.get('alias', {}) if isinstance(a_val, dict) and 'alias' in a_val else (a_val if isinstance(a_val, dict) else {})
if orig_k == target_model_name or a_dict.get('title') == target_model_name or a_dict.get('name') == target_model_name:
alias_cfg = a_dict
break
if alias_cfg:
if alias_cfg.get('model_name'):
actual_model = alias_cfg.get('model_name')
alias_ctx = alias_cfg.get('forced_context_size') or alias_cfg.get('ctx_size')
if alias_ctx:
try:
parsed = int(alias_ctx)
if parsed > 1:
found_alias_ctx = parsed
except (ValueError, TypeError):
pass
if not alias_cfg.get('allow_parameters_override', True):
for param_k in ['temperature', 'top_k', 'top_p', 'repeat_penalty', 'repeat_last_n', 'reasoning_activation', 'reasoning_effort', 'reasoning_summary']:
if alias_cfg.get(param_k) is not None:
primary_config[param_k] = alias_cfg[param_k]
primary_config["model_name"] = actual_model
if found_alias_ctx and found_alias_ctx > 1:
primary_config["ctx_size"] = found_alias_ctx
elif forced_ctx and int(forced_ctx) > 1:
primary_config["ctx_size"] = int(forced_ctx)
elif not primary_config.get("ctx_size") or int(primary_config.get("ctx_size", 0)) <= 1:
primary_config["ctx_size"] = 4096
primary_config.update(final_user_params)
primary_config["model_name"] = actual_model
# Ensure ctx_size wasn't wiped out by user_params
if found_alias_ctx and found_alias_ctx > 1:
primary_config["ctx_size"] = found_alias_ctx
client_init_params = {
"load_llm": load_llm,
"load_tti": load_tti,
"load_tts": load_tts,
"load_stt": load_stt,
"llm_binding_profiles": llm_binding_profiles,
"llm_model_profiles": llm_model_profiles,
"tti_binding_profiles": tti_binding_profiles,
"tti_model_profiles": tti_model_profiles,
"tts_binding_profiles": tts_binding_profiles,
"tts_model_profiles": tts_model_profiles,
"stt_binding_profiles": stt_binding_profiles,
"stt_model_profiles": stt_model_profiles,
"llm_binding_name": primary_binding.name if primary_binding else None,
"llm_binding_config": primary_config
}
if load_llm and load_mcp:
servers_infos = session.get('servers_infos')
if servers_infos is not None:
client_init_params["tools_binding_name"] = "remote_mcp"
client_init_params["tools_binding_config"] = {"servers_infos": servers_infos}
try:
registry_payload = {k: v for k, v in client_init_params.items() if v is not None}
registry_key = str(hash(json.dumps(registry_payload, sort_keys=True, default=str)))
with _registry_lock:
if registry_key in _global_client_registry:
if callback:
callback("⚡ Universal Engine cached - Instant access enabled.", 28, {})
return _global_client_registry[registry_key]
try:
lc = LollmsClient(**registry_payload, callback=callback)
_global_client_registry[registry_key] = lc
return lc
except Exception as engine_err:
error_msg = str(engine_err)
binding_alias_to_show = target_binding_alias or 'N/A'
ASCIIColors.warning(f"Engine Load Failed >> Binding: {binding_alias_to_show} | Error: {error_msg}")
if callback:
callback(f"⚠️ Configuration Issue: {error_msg}", 24, {})
degraded_payload = registry_payload.copy()
degraded_payload["load_llm"] = False
degraded_payload["load_tti"] = False
degraded_payload["load_tts"] = False
degraded_payload["load_stt"] = False
degraded_payload.pop("llm_binding_name", None)
degraded_payload.pop("llm_binding_config", None)
degraded_payload.pop("llm_binding_profiles", None)
degraded_payload.pop("llm_model_profiles", None)
degraded_lc = LollmsClient(**degraded_payload)
return degraded_lc
except Exception as e:
traceback.print_exc()
raise HTTPException(status_code=500, detail=f"System error during engine registry: {str(e)}")
finally:
db.close()
def _migrate_datastore_sqlite_schema(db_path: Path):
if not db_path.exists() or db_path.is_dir():
return
import sqlite3
try:
conn = sqlite3.connect(str(db_path))
cursor = conn.cursor()
cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
tables = {row[0] for row in cursor.fetchall()}
if "documents" in tables:
cursor.execute("PRAGMA table_info(documents)")
doc_cols = {row[1] for row in cursor.fetchall()}
if "full_text" not in doc_cols:
cursor.execute("ALTER TABLE documents ADD COLUMN full_text TEXT")
if "metadata" not in doc_cols:
cursor.execute("ALTER TABLE documents ADD COLUMN metadata TEXT")
if "created_at" not in doc_cols:
cursor.execute("ALTER TABLE documents ADD COLUMN created_at DATETIME")
if "updated_at" not in doc_cols:
cursor.execute("ALTER TABLE documents ADD COLUMN updated_at DATETIME")
conn.commit()
if "chunks" in tables:
cursor.execute("PRAGMA table_info(chunks)")
chunk_cols = {row[1] for row in cursor.fetchall()}
if "metadata" not in chunk_cols:
cursor.execute("ALTER TABLE chunks ADD COLUMN metadata TEXT")
if "chunk_index" not in chunk_cols:
cursor.execute("ALTER TABLE chunks ADD COLUMN chunk_index INTEGER")
conn.commit()
conn.close()
except Exception as e:
print(f"Warning: Failed to auto-migrate SQLite schema for {db_path.name}: {e}")
def get_safe_store_instance(
requesting_user_username: str,
datastore_id: str,
db: Session,
permission_level: str = "read_query"
) -> Any:
if safe_store is None:
raise HTTPException(status_code=501, detail="SafeStore library not installed. RAG is disabled.")
datastore_record = db.query(DBDataStore).options(joinedload(DBDataStore.owner)).filter(DBDataStore.id == datastore_id).first()
if not datastore_record:
raise HTTPException(status_code=404, detail=f"DataStore '{datastore_id}' not found.")
owner_username = datastore_record.owner.username
requesting_user_record = db.query(DBUser).filter(DBUser.username == requesting_user_username).first()
if not requesting_user_record:
raise HTTPException(status_code=404, detail="Requesting user not found.")
is_owner = (owner_username == requesting_user_username)
if not is_owner:
link = db.query(DBSharedDataStoreLink).filter_by(
datastore_id=datastore_id,
shared_with_user_id=requesting_user_record.id
).first()
if not link:
raise HTTPException(status_code=403, detail="Access denied to this DataStore.")
user_permission = link.permission_level
permission_hierarchy = {
"read_query": ["read_query", "read_write", "revectorize"],
"read_write": ["read_write", "revectorize"],
"revectorize": ["revectorize"]
}
if user_permission not in permission_hierarchy.get(permission_level, []):
raise HTTPException(
status_code=403,
detail=f"You do not have the required '{permission_level}' permission for this DataStore."
)
session = user_sessions.get(requesting_user_username)
if not session:
raise HTTPException(status_code=500, detail="User session not found for SafeStore access.")
if datastore_id not in session.get("safe_store_instances", {}):
ss_db_path = get_datastore_db_path(owner_username, datastore_id)
_migrate_datastore_sqlite_schema(ss_db_path)
try:
vectorizer_config = datastore_record.vectorizer_config or {}
if isinstance(vectorizer_config, str):
try:
vectorizer_config = json.loads(vectorizer_config)
except Exception:
vectorizer_config = {}
v_config = vectorizer_config.copy()
if 'model_name' in v_config and 'model' not in v_config:
v_config['model'] = v_config['model_name']
strategy = getattr(datastore_record, "chunking_strategy", "recursive") or "recursive"
strategy_kwargs = getattr(datastore_record, "chunking_kwargs", {}) or {}
ss_instance = safe_store.SafeStore(
name=datastore_record.name,
description=datastore_record.description,
db_path=ss_db_path,
vectorizer_name=datastore_record.vectorizer_name,
vectorizer_config=v_config,
chunk_size=datastore_record.chunk_size,
chunk_overlap=datastore_record.chunk_overlap,
expand_before=10,
expand_after=10,
chunking_strategy=strategy,
chunking_kwargs=strategy_kwargs if isinstance(strategy_kwargs, dict) else {}
)
ss_instance.name = datastore_record.name
ss_instance.description = datastore_record.description
session.setdefault("safe_store_instances", {})[datastore_id] = ss_instance
except Exception as e:
trace_exception(e)
raise HTTPException(status_code=500, detail=f"Could not initialize SafeStore for {datastore_id}: {str(e)}")
return session["safe_store_instances"][datastore_id]
def get_user_data_root(username: str) -> Path:
safe_username = secure_filename(username)
path = APP_DATA_DIR / USERS_DIR_NAME / safe_username
path.mkdir(parents=True, exist_ok=True)
(path / VOICES_DIR_NAME).mkdir(exist_ok=True)
return path
def get_user_images_path(username: str) -> Path:
path = get_user_data_root(username) / IMAGES_DIR_NAME
path.mkdir(parents=True, exist_ok=True)
return path
def get_user_discussion_path(username: str) -> Path:
path = get_user_data_root(username) / "discussions"
return path
def get_user_discussion_assets_path(username: str) -> Path:
path = get_user_data_root(username) / DISCUSSION_ASSETS_DIR_NAME
path.mkdir(parents=True, exist_ok=True)
return path
def get_user_dm_assets_path(username: str) -> Path:
path = get_user_data_root(username) / DM_ASSETS_DIR_NAME
path.mkdir(parents=True, exist_ok=True)
return path
def get_user_social_assets_path(username: str) -> Path:
path = get_user_data_root(username) / "social_assets"
path.mkdir(parents=True, exist_ok=True)
return path
def get_user_temp_uploads_path(username: str) -> Path:
path = get_user_data_root(username) / TEMP_UPLOADS_DIR_NAME
path.mkdir(parents=True, exist_ok=True)
return path
def get_user_datastore_root_path(username: str) -> Path:
path = get_user_data_root(username) / DATASTORES_DIR_NAME
path.mkdir(parents=True, exist_ok=True)
return path
def get_datastore_db_path(owner_username: str, datastore_id: str) -> Path:
safe_datastore_id = secure_filename(datastore_id)
return get_user_datastore_root_path(owner_username) / f"{safe_datastore_id}.db"
def get_user_notebook_assets_path(username: str, notebook_id: str) -> Path:
path = get_user_data_root(username) / NOTEBOOK_ASSETS_DIR_NAME / secure_filename(notebook_id)
path.mkdir(parents=True, exist_ok=True)
return path
def find_model_by_alias(db: Session, alias_title: str) -> Tuple[Optional[str], Optional[str]]:
all_bindings = db.query(DBLLMBinding).filter(DBLLMBinding.is_active == True).all()
for binding in all_bindings:
model_aliases = binding.model_aliases or {}
if isinstance(model_aliases, str):
try:
model_aliases = json.loads(model_aliases)
except Exception:
continue
for original_name, alias_data in model_aliases.items():
if alias_data:
title = alias_data.get('title') or (alias_data.get('alias', {}).get('title') if isinstance(alias_data, dict) else None)
target = alias_data.get('model_name') or (alias_data.get('alias', {}).get('model_name') if isinstance(alias_data, dict) else None)
if title == alias_title or original_name == alias_title:
return binding.alias, target or original_name
return None, None
def invalidate_model_cache(db: Session):
db.query(GlobalConfig).filter(GlobalConfig.key == "cache_available_models").delete()
db.commit()
with _registry_lock:
_global_client_registry.clear()
from backend.ws_manager import manager
manager.broadcast_internal_event_sync("global_model_cache_invalidate", {})
def resolve_model_name(db: Session, requested_model: str, fallback_to_default: bool = True) -> Tuple[str, str]:
if not requested_model:
if fallback_to_default:
default_binding = db.query(DBLLMBinding).filter(DBLLMBinding.is_active == True).order_by(DBLLMBinding.id).first()
if default_binding:
return default_binding.alias, default_binding.default_model_name
raise HTTPException(status_code=400, detail="Model name is empty.")
if '/' in requested_model:
parts = requested_model.split('/', 1)
binding = db.query(DBLLMBinding).filter(DBLLMBinding.alias == parts[0], DBLLMBinding.is_active == True).first()
if binding:
model_aliases = binding.model_aliases or {}
if isinstance(model_aliases, str):
try:
model_aliases = json.loads(model_aliases)
except Exception:
model_aliases = {}
for original_name, alias_data in model_aliases.items():
if alias_data:
title = alias_data.get('title') or (alias_data.get('alias', {}).get('title') if isinstance(alias_data, dict) else None)
target = alias_data.get('model_name') or (alias_data.get('alias', {}).get('model_name') if isinstance(alias_data, dict) else None)
if title == parts[1] or original_name == parts[1]:
return parts[0], target or original_name
return parts[0], parts[1]
binding_alias, model_name = find_model_by_alias(db, requested_model)
if binding_alias:
return binding_alias, model_name
if fallback_to_default:
default_binding = db.query(DBLLMBinding).filter(DBLLMBinding.is_active == True).order_by(DBLLMBinding.id).first()
if default_binding:
ASCIIColors.warning(f"Model '{requested_model}' not found. Falling back to default: {default_binding.alias}/{default_binding.default_model_name}")
return default_binding.alias, default_binding.default_model_name
invalidate_model_cache(db)
raise HTTPException(status_code=400, detail=f"Model '{requested_model}' not found. Please use 'binding/model_name' format or a valid profile alias.")
# backend/session.py
import os
import json
import traceback
import datetime
import threading
from pathlib import Path
from typing import Dict, Optional, Any, cast, Callable, Tuple
from urllib.parse import urlparse
from fastapi import HTTPException, Depends, status
from sqlalchemy.orm import Session, joinedload, object_session
from werkzeug.utils import secure_filename
from ascii_colors import trace_exception, ASCIIColors
from backend.db import get_db
from backend.db.models.user import User as DBUser
from backend.db.models.service import MCP as DBMCP, App as DBApp
from backend.db.models.datastore import DataStore as DBDataStore, SharedDataStoreLink as DBSharedDataStoreLink
from backend.db.models.personality import Personality as DBPersonality
from backend.db.models.config import (
GlobalConfig, LLMBinding as DBLLMBinding, TTIBinding as DBTTIBinding,
TTSBinding as DBTTSBinding, STTBinding as DBSTTBinding
)
from lollms_client import LollmsClient
from backend.models.user import UserAuthDetails
from backend.models.auth import TokenData
from backend.security import oauth2_scheme, decode_main_access_token
from backend.config import (
APP_DATA_DIR,
SAFE_STORE_DEFAULTS,
USERS_DIR_NAME,
TEMP_UPLOADS_DIR_NAME,
DISCUSSION_ASSETS_DIR_NAME,
DM_ASSETS_DIR_NAME,
DATASTORES_DIR_NAME,
VOICES_DIR_NAME,
IMAGES_DIR_NAME,
NOTEBOOK_ASSETS_DIR_NAME
)
from backend.settings import settings
from backend.security import create_access_token
try:
import safe_store
except ImportError:
safe_store = None
# Global In-Memory Session Cache
user_sessions: Dict[str, Dict[str, Any]] = {}
# Authentication Cache to prevent DB bombardment during request bursts
_token_user_cache: Dict[str, tuple] = {}
_token_cache_lock = threading.Lock()
TOKEN_CACHE_TTL = 10 # seconds
# Global Client Registry to prevent file descriptor exhaustion
_global_client_registry: Dict[str, LollmsClient] = {}
_registry_lock = threading.Lock()
# Locks to prevent race conditions during concurrent requests
_session_init_lock = threading.Lock()
_client_build_locks: Dict[str, threading.Lock] = {}
_client_build_locks_lock = threading.Lock()
def ensure_bool(value, default=False):
if isinstance(value, bool):
return value
elif isinstance(value, str):
try:
return value.lower() in ("true", "yes", "1")
except Exception:
return default
else:
return default
def get_user_by_username(db: Session, username: str) -> Optional[DBUser]:
return db.query(DBUser).filter(DBUser.username == username).first()
async def get_current_db_user_from_token(
token: str = Depends(oauth2_scheme),
db: Session = Depends(get_db)
) -> DBUser:
now = datetime.datetime.now(datetime.timezone.utc)
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
payload = decode_main_access_token(token)
if payload is None:
raise credentials_exception
username: str = payload.get("sub")
if username is None:
raise credentials_exception
with _token_cache_lock:
Xet Storage Details
- Size:
- 56.7 kB
- Xet hash:
- e320091326daaaff74833cdb56cb86eb3a51b9a72208ae7b279d2eb838f0e6fe
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.