| import shutil | |
| import datetime | |
| from pathlib import Path | |
| from typing import Optional | |
| import os | |
| import subprocess | |
| import sys | |
| from multiprocessing import cpu_count, Lock, set_start_method | |
| from urllib.parse import urlparse | |
| import pipmaster as pm | |
| pm.ensure_packages(["ascii_colors>=0.11.13", "lollms_client>=1.12.4"]) | |
| from ascii_colors import ASCIIColors, trace_exception, Live, Panel, Console | |
| import asyncio | |
| import time | |
| import threading | |
| from concurrent.futures import ThreadPoolExecutor | |
| from threading import Lock | |
| from multipart.multipart import FormParser | |
| FormParser.max_size = 50 * 1024 * 1024 # 50 MB | |
| from fastapi import FastAPI, Depends, HTTPException | |
| from fastapi.middleware.cors import CORSMiddleware | |
| from sqlalchemy.orm import Session | |
| from sqlalchemy import or_, inspect, desc | |
| from backend.lollms_init_watcher import lollms_init_watcher | |
| from backend.config import ( | |
| APP_SETTINGS, APP_VERSION, APP_DB_URL, | |
| INITIAL_ADMIN_USER_CONFIG, SERVER_CONFIG, | |
| APPS_ZOO_ROOT_PATH, MCPS_ZOO_ROOT_PATH, PROMPTS_ZOO_ROOT_PATH, PERSONALITIES_ZOO_ROOT_PATH, SKILLS_ZOO_ROOT_PATH | |
| ) | |
| from backend.db import init_database, get_db, session as db_session_module | |
| from backend.db.base import Base, TaskStatus | |
| from backend.db.migration import run_schema_migrations_and_bootstrap, check_and_update_db_version | |
| from backend.db.models.user import User as DBUser | |
| from backend.db.models.personality import Personality as DBPersonality | |
| from backend.db.models.prompt import SavedPrompt as DBSavedPrompt | |
| from backend.db.models.config import LLMBinding as DBLLMBinding | |
| from backend.db.models.service import AppZooRepository as DBAppZooRepository, App as DBApp, MCP as DBMCP, MCPZooRepository as DBMCPZooRepository, PromptZooRepository as DBPromptZooRepository, PersonalityZooRepository as DBPersonalityZooRepository, SkillZooRepository as DBSkillZooRepository | |
| from backend.db.models.connections import WebSocketConnection | |
| from backend.db.models.db_task import DBTask | |
| from backend.security import get_password_hash as hash_password | |
| from backend.migration_utils import LegacyDiscussion | |
| from backend.session import ( | |
| get_user_data_root, get_user_discussion_path, user_sessions, | |
| build_lollms_client_from_params, get_user_lollms_client | |
| ) | |
| from lollms_client import LollmsDataManager | |
| from backend.settings import settings | |
| from backend.routers.auth import auth_router | |
| from backend.routers.admin import admin_router | |
| from backend.routers.languages import languages_router | |
| from backend.routers.personalities import personalities_router | |
| from backend.routers.friends import friends_router | |
| from backend.routers.groups import groups_router | |
| from backend.routers.social.dm import dm_router | |
| from backend.routers.stores import store_files_router, datastore_router | |
| from backend.routers.extensions import apps_router, mcp_router, discussion_tools_router | |
| from backend.routers.social import social_router | |
| from backend.routers.users import users_router | |
| from backend.routers.social.dm_ws import dm_ws_router | |
| from backend.routers.api_keys import api_keys_router | |
| from backend.routers.services.openai_v1 import openai_v1_router | |
| from backend.routers.services.ollama_v1 import ollama_v1_router | |
| from backend.routers.lollms_config import lollms_config_router | |
| from backend.routers.files import upload_router, assets_router, files_router | |
| from backend.routers.ui import add_ui_routes, ui_router | |
| from backend.routers.sso import sso_router | |
| from backend.routers.sso_client import sso_client_router | |
| from backend.routers.scim import scim_router | |
| from backend.routers.extensions.app_utils import cleanup_and_autostart_apps, synchronize_filesystem_and_db | |
| from backend.routers.zoos.apps_zoo import apps_zoo_router | |
| from backend.routers.zoos.mcps_zoo import mcps_zoo_router | |
| from backend.routers.zoos.prompts_zoo import prompts_zoo_router | |
| from backend.routers.zoos.personalities_zoo import personalities_zoo_router | |
| from backend.routers.zoos.skills_zoo import skills_zoo_router | |
| from backend.routers.discussion_groups import discussion_groups_router | |
| from backend.routers.voices_studio import voices_studio_router | |
| from backend.routers.image_studio import image_studio_router | |
| from backend.routers.notes import notes_router | |
| from backend.routers.notebooks import router as notebooks_router | |
| from backend.routers.public import public_router | |
| from backend.routers.flow_studio import router as flow_studio_router | |
| from backend.routers.services.lollms_v1 import lollms_v1_router | |
| from backend.tasks.email_tasks import _generate_email_proposal_task | |
| from backend.routers.tasks import tasks_router | |
| from backend.routers.skills import skills_router | |
| from backend.task_manager import task_manager | |
| from backend.ws_manager import manager, listen_for_broadcasts | |
| from backend.routers.help import help_router | |
| from backend.routers.prompts import prompts_router | |
| from backend.routers.memories import memories_router | |
| from backend.routers.news import news_router | |
| from backend.zoo_cache import load_cache | |
| from backend.routers.discussion import build_discussions_router | |
| import uvicorn | |
| from apscheduler.schedulers.background import BackgroundScheduler | |
| from backend.tasks.news_tasks import _scrape_rss_feeds_task, _cleanup_old_news_articles_task | |
| from backend.tasks.social_tasks import _generate_feed_post_task | |
| from backend.tasks.system_tasks import _prune_old_tasks_task | |
| broadcast_listener_task = None | |
| rss_scheduler = None | |
| startup_lock = Lock() | |
| def scheduled_rss_job(): | |
| active_tasks = task_manager.get_all_tasks() | |
| if any(t.name == "Scheduled RSS Feed Scraping" and t.status in ['running', 'pending'] for t in active_tasks): | |
| return | |
| task_manager.submit_task( | |
| name="Scheduled RSS Feed Scraping", | |
| target=_scrape_rss_feeds_task, | |
| description="Periodically fetching and processing all active RSS feeds.", | |
| owner_username=None | |
| ) | |
| def scheduled_news_cleanup_job(): | |
| task_manager.submit_task( | |
| name="Daily News Article Cleanup", | |
| target=_cleanup_old_news_articles_task, | |
| description="Deleting old news articles based on retention policy.", | |
| owner_username=None | |
| ) | |
| def scheduled_task_pruning_job(): | |
| db = db_session_module.SessionLocal() | |
| try: | |
| settings.load_from_db(db) | |
| if not settings.get("tasks_auto_cleanup", True): | |
| return | |
| task_manager.submit_task( | |
| name="Scheduled Task Pruning", | |
| target=_prune_old_tasks_task, | |
| description="Automatic background cleanup of old finished tasks.", | |
| owner_username=None | |
| ) | |
| finally: | |
| db.close() | |
| def check_and_run_scheduled_posts(): | |
| db = db_session_module.SessionLocal() | |
| try: | |
| settings.load_from_db(db) | |
| if not settings.get("ai_bot_auto_post", False): | |
| return | |
| schedule = settings.get("ai_bot_post_schedule", []) | |
| if not schedule: | |
| return | |
| last_posted_str = settings.get("ai_bot_last_posted_at") | |
| last_posted = None | |
| if last_posted_str: | |
| try: | |
| last_posted = datetime.datetime.fromisoformat(last_posted_str) | |
| except ValueError: pass | |
| now = datetime.datetime.now() | |
| current_time_str = now.strftime("%H:%M") | |
| should_post = False | |
| for time_slot in schedule: | |
| if current_time_str == time_slot: | |
| if last_posted: | |
| time_diff = now - last_posted | |
| if time_diff.total_seconds() < 3540: | |
| continue | |
| should_post = True | |
| break | |
| if should_post: | |
| task_manager.submit_task( | |
| name="AI Bot Scheduled Post", | |
| target=_generate_feed_post_task, | |
| args=(True,), | |
| description=f"Scheduled post for {current_time_str}", | |
| owner_username=None | |
| ) | |
| except Exception as e: | |
| print(f"Error in scheduler check: {e}") | |
| finally: | |
| db.close() | |
| def scheduled_email_proposal_job(): | |
| task_manager.submit_task( | |
| name="Generate Email Proposal", | |
| target=_generate_email_proposal_task, | |
| description="Lollms researching and drafting email content.", | |
| owner_username=None | |
| ) | |
| startup_executor = ThreadPoolExecutor(max_workers=10, thread_name_prefix="lollms_startup") | |
| def run_one_time_startup_tasks(lock: Lock): | |
| acquired = lock.acquire(blocking=False) | |
| if not acquired: | |
| return | |
| ASCIIColors.panel(f"ℹ️ Worker [bold]{os.getpid()}[/bold] acquired startup lock. Running one-time tasks... 🚀") | |
| steps = [ | |
| ("Database tables check/creation", False), | |
| ("Schema migration & bootstrap", False), | |
| ("Legacy discussion migration", False), | |
| ("Default admin & DB entries", False), | |
| ("App Zoo repository setup", False), | |
| ("MCP Zoo repository setup", False), | |
| ("Prompt Zoo repository setup", False), | |
| ("Personality Zoo repository setup", False), | |
| ("Skill Zoo repository setup", False), | |
| ("Filesystem‑DB synchronization", False), | |
| ("Stale WebSocket & task cleanup", False), | |
| ("Autostart & cleanup", False) | |
| ] | |
| def render_steps_panel(): | |
| lines = [] | |
| for description, done in steps: | |
| checkbox = "[green]✔[/green]" if done else "[red]✘[/red]" | |
| lines.append(f"{checkbox} {description}") | |
| markdown = "\n".join(lines) | |
| return ASCIIColors.panel(markdown, title="🛠️ Startup Progress", border_style="cyan") | |
| try: | |
| engine = db_session_module.engine | |
| Base.metadata.create_all(bind=engine) | |
| steps[0] = (steps[0][0], True) | |
| render_steps_panel() | |
| except Exception as e: | |
| ASCIIColors.error(f"Database table creation failed: {e}") | |
| trace_exception(e) | |
| lock.release() | |
| raise | |
| try: | |
| with engine.connect() as connection: | |
| inspector = inspect(connection) | |
| run_schema_migrations_and_bootstrap(connection, inspector) | |
| ASCIIColors.green("INFO: Schema migration completed.") | |
| check_and_update_db_version(db_session_module.SessionLocal) | |
| steps[1] = (steps[1][0], True) | |
| render_steps_panel() | |
| except Exception as e: | |
| ASCIIColors.error(f"Schema migration failed: {e}") | |
| trace_exception(e) | |
| lock.release() | |
| raise | |
| try: | |
| if APP_SETTINGS.get("migrate"): | |
| db_session = None | |
| try: | |
| db_session = next(get_db()) | |
| all_users = db_session.query(DBUser).all() | |
| for user in all_users: | |
| username = user.username | |
| old_discussion_path = get_user_discussion_path(username) | |
| if not (old_discussion_path.exists() and old_discussion_path.is_dir()): | |
| continue | |
| if username not in user_sessions: | |
| user_sessions[username] = { | |
| "lollms_model_name": user.lollms_model_name, | |
| "llm_params": {} | |
| } | |
| db_path = get_user_data_root(username) / "discussions.db" | |
| dm = LollmsDataManager(db_path=f"sqlite:///{db_path.resolve()}") | |
| migrated_count = 0 | |
| for file_path in old_discussion_path.glob("*.yaml"): | |
| discussion_db_session = None | |
| try: | |
| old_disc = LegacyDiscussion.load_from_yaml(file_path) | |
| if not old_disc: | |
| continue | |
| discussion_db_session = dm.get_session() | |
| if discussion_db_session.query(dm.DiscussionModel).filter_by(id=old_disc.discussion_id).first(): | |
| discussion_db_session.close() | |
| continue | |
| new_db_disc_orm = dm.DiscussionModel( | |
| id=old_disc.discussion_id, | |
| discussion_metadata={"title": old_disc.title, "rag_datastore_ids": old_disc.rag_datastore_ids}, | |
| active_branch_id=old_disc.active_branch_id | |
| ) | |
| discussion_db_session.add(new_db_disc_orm) | |
| for msg in old_disc.messages: | |
| msg_orm = dm.MessageModel( | |
| id=msg.id, | |
| discussion_id=new_db_disc_orm.id, | |
| parent_id=msg.parent_id, | |
| sender=msg.sender, | |
| sender_type=msg.sender_type, | |
| content=msg.content, | |
| created_at=msg.created_at, | |
| binding_name=msg.binding_name, | |
| model_name=msg.model_name, | |
| tokens=msg.token_count, | |
| message_metadata={"sources": msg.sources, "steps": msg.steps} | |
| ) | |
| discussion_db_session.add(msg_orm) | |
| discussion_db_session.commit() | |
| migrated_count += 1 | |
| except Exception as e: | |
| if discussion_db_session: | |
| discussion_db_session.rollback() | |
| finally: | |
| if discussion_db_session: | |
| discussion_db_session.close() | |
| if migrated_count > 0: | |
| backup_path = old_discussion_path.parent / f"{old_discussion_path.name}_migrated_{datetime.datetime.now().strftime('%Y%m%d%H%M%S')}" | |
| shutil.move(str(old_discussion_path), str(backup_path)) | |
| finally: | |
| if db_session: | |
| db_session.close() | |
| steps[2] = (steps[2][0], True) | |
| render_steps_panel() | |
| except Exception as e: | |
| trace_exception(e) | |
| try: | |
| db_for_defaults = next(get_db()) | |
| admin_username = INITIAL_ADMIN_USER_CONFIG.get("username", "admin") | |
| admin_password = INITIAL_ADMIN_USER_CONFIG.get("password", "admin") | |
| admin_exists = db_for_defaults.query(DBUser).filter(DBUser.is_admin == True).first() is not None | |
| if not admin_exists: | |
| existing_user = db_for_defaults.query(DBUser).filter(DBUser.username == admin_username).first() | |
| if existing_user: | |
| existing_user.is_admin = True | |
| existing_user.is_active = True | |
| existing_user.status = "active" | |
| db_for_defaults.commit() | |
| else: | |
| new_admin = DBUser( | |
| username=admin_username, | |
| hashed_password=hash_password(admin_password), | |
| is_admin=True, | |
| is_active=True, | |
| status="active" | |
| ) | |
| db_for_defaults.add(new_admin) | |
| db_for_defaults.commit() | |
| steps[3] = (steps[3][0], True) | |
| render_steps_panel() | |
| except Exception as e: | |
| trace_exception(e) | |
| finally: | |
| if db_for_defaults: | |
| db_for_defaults.close() | |
| try: | |
| db_for_repos = next(get_db()) | |
| app_zoo_name = "Official LoLLMs Apps Zoo" | |
| app_zoo_url = "https://github.com/ParisNeo/lollms_apps_zoo.git" | |
| app_zoo_repo_path = APPS_ZOO_ROOT_PATH / app_zoo_name | |
| if not db_for_repos.query(DBAppZooRepository).filter( | |
| or_(DBAppZooRepository.name == app_zoo_name, DBAppZooRepository.url == app_zoo_url) | |
| ).first(): | |
| default_repo = DBAppZooRepository(name=app_zoo_name, url=app_zoo_url, is_deletable=False) | |
| db_for_repos.add(default_repo) | |
| db_for_repos.commit() | |
| if not app_zoo_repo_path.exists(): | |
| subprocess.run(["git", "clone", app_zoo_url, str(app_zoo_repo_path)], check=True) | |
| steps[4] = (steps[4][0], True) | |
| render_steps_panel() | |
| except Exception as e: | |
| trace_exception(e) | |
| finally: | |
| if db_for_repos: | |
| db_for_repos.close() | |
| try: | |
| db_for_mcps = next(get_db()) | |
| mcp_zoo_name = "lollms_mcps_zoo" | |
| mcp_zoo_url = "https://github.com/ParisNeo/lollms_mcps_zoo.git" | |
| mcp_zoo_repo_path = MCPS_ZOO_ROOT_PATH / mcp_zoo_name | |
| if not db_for_mcps.query(DBMCPZooRepository).filter( | |
| or_(DBMCPZooRepository.name == mcp_zoo_name, DBMCPZooRepository.url == mcp_zoo_url) | |
| ).first(): | |
| default_mcp_repo = DBMCPZooRepository(name=mcp_zoo_name, url=mcp_zoo_url, is_deletable=False) | |
| db_for_mcps.add(default_mcp_repo) | |
| db_for_mcps.commit() | |
| if not mcp_zoo_repo_path.exists(): | |
| subprocess.run(["git", "clone", mcp_zoo_url, str(mcp_zoo_repo_path)], check=True) | |
| steps[5] = (steps[5][0], True) | |
| render_steps_panel() | |
| except Exception as e: | |
| trace_exception(e) | |
| finally: | |
| if db_for_mcps: | |
| db_for_mcps.close() | |
| try: | |
| db_for_prompts = next(get_db()) | |
| prompt_zoo_name = "lollms_prompts_zoo" | |
| prompt_zoo_url = "https://github.com/ParisNeo/lollms_prompts_zoo.git" | |
| prompt_zoo_repo_path = PROMPTS_ZOO_ROOT_PATH / prompt_zoo_name | |
| if not db_for_prompts.query(DBPromptZooRepository).filter( | |
| or_(DBPromptZooRepository.name == prompt_zoo_name, DBPromptZooRepository.url == prompt_zoo_url) | |
| ).first(): | |
| default_prompt_repo = DBPromptZooRepository(name=prompt_zoo_name, url=prompt_zoo_url, is_deletable=False) | |
| db_for_prompts.add(default_prompt_repo) | |
| db_for_prompts.commit() | |
| if not prompt_zoo_repo_path.exists(): | |
| subprocess.run(["git", "clone", prompt_zoo_url, str(prompt_zoo_repo_path)], check=True) | |
| steps[6] = (steps[6][0], True) | |
| render_steps_panel() | |
| except Exception as e: | |
| trace_exception(e) | |
| finally: | |
| if db_for_prompts: | |
| db_for_prompts.close() | |
| try: | |
| db_for_personalities = next(get_db()) | |
| personality_zoo_name = "lollms_personalities_zoo" | |
| personality_zoo_url = "https://github.com/ParisNeo/lollms_personalities_zoo.git" | |
| personality_zoo_repo_path = PERSONALITIES_ZOO_ROOT_PATH / personality_zoo_name | |
| if not db_for_personalities.query(DBPersonalityZooRepository).filter( | |
| or_(DBPersonalityZooRepository.name == personality_zoo_name, DBPersonalityZooRepository.url == personality_zoo_url) | |
| ).first(): | |
| default_personality_repo = DBPersonalityZooRepository(name=personality_zoo_name, url=personality_zoo_url, is_deletable=False) | |
| db_for_personalities.add(default_personality_repo) | |
| db_for_personalities.commit() | |
| if not personality_zoo_repo_path.exists(): | |
| subprocess.run(["git", "clone", personality_zoo_url, str(personality_zoo_repo_path)], check=True) | |
| steps[7] = (steps[7][0], True) | |
| render_steps_panel() | |
| except Exception as e: | |
| trace_exception(e) | |
| finally: | |
| if db_for_personalities: | |
| db_for_personalities.close() | |
| try: | |
| db_for_skills = next(get_db()) | |
| skill_zoo_name = "lollms_skills_zoo" | |
| skill_zoo_url = "https://github.com/ParisNeo/lollms_skills_zoo.git" | |
| skill_zoo_repo_path = SKILLS_ZOO_ROOT_PATH / skill_zoo_name | |
| if not db_for_skills.query(DBSkillZooRepository).filter( | |
| or_(DBSkillZooRepository.name == skill_zoo_name, DBSkillZooRepository.url == skill_zoo_url) | |
| ).first(): | |
| default_skill_repo = DBSkillZooRepository(name=skill_zoo_name, url=skill_zoo_url, is_deletable=False) | |
| db_for_skills.add(default_skill_repo) | |
| db_for_skills.commit() | |
| if not skill_zoo_repo_path.exists(): | |
| subprocess.run(["git", "clone", skill_zoo_url, str(skill_zoo_repo_path)], check=True) | |
| steps[8] = (steps[8][0], True) | |
| render_steps_panel() | |
| except Exception as e: | |
| trace_exception(e) | |
| finally: | |
| if db_for_skills: | |
| db_for_skills.close() | |
| try: | |
| db_for_sync = next(get_db()) | |
| synchronize_filesystem_and_db(db_for_sync) | |
| steps[8] = (steps[8][0], True) | |
| render_steps_panel() | |
| except Exception as e: | |
| trace_exception(e) | |
| finally: | |
| if db_for_sync: | |
| db_for_sync.close() | |
| try: | |
| db_for_cleanup = next(get_db()) | |
| db_for_cleanup.query(WebSocketConnection).delete() | |
| interrupted_tasks = db_for_cleanup.query(DBTask).filter( | |
| DBTask.status.in_([TaskStatus.RUNNING, TaskStatus.PENDING]) | |
| ).all() | |
| if interrupted_tasks: | |
| for task in interrupted_tasks: | |
| task.status = TaskStatus.FAILED | |
| task.error = "Task interrupted by server restart." | |
| task.completed_at = datetime.datetime.now(datetime.timezone.utc) | |
| task.logs = [{"timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(), "message": "System Restart Recovery", "level": "ERROR"}] | |
| db_for_cleanup.commit() | |
| steps[9] = (steps[9][0], True) | |
| render_steps_panel() | |
| except Exception as e: | |
| trace_exception(e) | |
| finally: | |
| if db_for_cleanup: | |
| db_for_cleanup.close() | |
| try: | |
| load_cache() | |
| task_manager.init_app(db_session_module.SessionLocal) | |
| cleanup_and_autostart_apps() | |
| steps[10] = (steps[10][0], True) | |
| render_steps_panel() | |
| except Exception as e: | |
| trace_exception(e) | |
| try: | |
| db_warmup = next(get_db()) | |
| active_llm_bindings = db_warmup.query(DBLLMBinding).filter(DBLLMBinding.is_active == True).all() | |
| if active_llm_bindings: | |
| for binding in active_llm_bindings: | |
| startup_executor.submit( | |
| build_lollms_client_from_params, | |
| "lollms", | |
| binding_alias=binding.alias, | |
| load_llm=True, | |
| callback=lollms_init_watcher | |
| ) | |
| db_warmup.close() | |
| steps.append(("Pre-warm Active Bindings", True)) | |
| except Exception as e: | |
| trace_exception(e) | |
| lock.release() | |
| async def startup_event(): | |
| global broadcast_listener_task, rss_scheduler, startup_lock | |
| init_database(APP_DB_URL) | |
| run_one_time_startup_tasks(startup_lock) | |
| db = db_session_module.SessionLocal() | |
| try: | |
| settings.load_from_db(db) | |
| active_bindings = db.query(DBLLMBinding).filter(DBLLMBinding.is_active == True).all() | |
| if active_bindings: | |
| loop = asyncio.get_running_loop() | |
| for b in active_bindings: | |
| loop.run_in_executor( | |
| startup_executor, | |
| get_user_lollms_client, | |
| "lollms", | |
| b.alias | |
| ) | |
| finally: | |
| db.close() | |
| manager.set_loop(asyncio.get_running_loop()) | |
| task_manager.init_app(db_session_module.SessionLocal) | |
| if SERVER_CONFIG.get("workers", 1) > 1: | |
| broadcast_listener_task = asyncio.create_task(listen_for_broadcasts()) | |
| if os.getpid() == os.getppid() or os.getenv("WORKER_ID") == "1": | |
| rss_scheduler = BackgroundScheduler(daemon=True) | |
| if settings.get("rss_feed_enabled"): | |
| interval = settings.get("rss_feed_check_interval_minutes", 60) | |
| next_run = datetime.datetime.now() + datetime.timedelta(seconds=20) | |
| rss_scheduler.add_job(scheduled_rss_job, 'interval', minutes=interval, next_run_time=next_run) | |
| retention_days = settings.get("rss_news_retention_days", 1) | |
| if retention_days > 0: | |
| rss_scheduler.add_job(scheduled_news_cleanup_job, 'cron', hour=3, minute=0) | |
| rss_scheduler.add_job(check_and_run_scheduled_posts, 'interval', minutes=1) | |
| rss_scheduler.add_job(scheduled_task_pruning_job, 'cron', hour=4, minute=0) | |
| if settings.get("email_marketing_enabled", False): | |
| rss_scheduler.add_job( | |
| scheduled_email_proposal_job, | |
| 'interval', | |
| hours=24, | |
| next_run_time=datetime.datetime.now() + datetime.timedelta(minutes=5) | |
| ) | |
| if not rss_scheduler.running: | |
| rss_scheduler.start() | |
| async def shutdown_event(): | |
| ASCIIColors.info(f"--- Worker process (PID: {os.getpid()}) shutting down. ---") | |
| if broadcast_listener_task: | |
| broadcast_listener_task.cancel() | |
| try: | |
| await broadcast_listener_task | |
| except asyncio.CancelledError: | |
| pass | |
| if rss_scheduler and rss_scheduler.running: | |
| rss_scheduler.shutdown() | |
| app = FastAPI( | |
| title="LoLLMs Platform", | |
| description="API for a multi-user LoLLMs and SafeStore chat application.", | |
| version=APP_VERSION, | |
| on_startup=[startup_event], | |
| on_shutdown=[shutdown_event] | |
| ) | |
| # Robust, Top-Level CORS Middleware Setup (Universal for all workers and preflight OPTIONS requests) | |
| app.add_middleware( | |
| CORSMiddleware, | |
| allow_origin_regex="https?://.*", | |
| allow_credentials=True, | |
| allow_methods=["*"], | |
| allow_headers=["*"], | |
| ) | |
| app.include_router(auth_router) | |
| app.include_router(admin_router) | |
| app.include_router(languages_router) | |
| app.include_router(personalities_router) | |
| app.include_router(friends_router) | |
| app.include_router(groups_router) | |
| app.include_router(dm_router) | |
| app.include_router(store_files_router) | |
| app.include_router(datastore_router) | |
| app.include_router(apps_router) | |
| app.include_router(mcp_router) | |
| app.include_router(discussion_tools_router) | |
| app.include_router(social_router) | |
| app.include_router(users_router) | |
| app.include_router(dm_ws_router) | |
| app.include_router(api_keys_router) | |
| app.include_router(openai_v1_router) | |
| app.include_router(ollama_v1_router) | |
| app.include_router(lollms_config_router) | |
| app.include_router(files_router) | |
| app.include_router(ui_router) | |
| app.include_router(sso_router) | |
| app.include_router(sso_client_router) | |
| app.include_router(scim_router) | |
| app.include_router(apps_zoo_router) | |
| app.include_router(mcps_zoo_router) | |
| app.include_router(prompts_zoo_router) | |
| app.include_router(personalities_zoo_router) | |
| app.include_router(skills_zoo_router) | |
| app.include_router(tasks_router) | |
| app.include_router(help_router) | |
| app.include_router(prompts_router) | |
| app.include_router(memories_router) | |
| app.include_router(news_router) | |
| app.include_router(upload_router) | |
| app.include_router(assets_router) | |
| app.include_router(build_discussions_router()) | |
| app.include_router(discussion_groups_router) | |
| app.include_router(voices_studio_router) | |
| app.include_router(image_studio_router) | |
| app.include_router(notes_router) | |
| app.include_router(notebooks_router) | |
| app.include_router(public_router) | |
| app.include_router(lollms_v1_router) | |
| app.include_router(flow_studio_router) | |
| app.include_router(skills_router) | |
| add_ui_routes(app) | |
| # Silence benign WinError 10054 connection reset tracebacks from Windows Proactor EventLoop | |
| if os.name == 'nt': | |
| from asyncio.proactor_events import _ProactorBasePipeTransport | |
| _orig_call_connection_lost = _ProactorBasePipeTransport._call_connection_lost | |
| def _silenced_call_connection_lost(self, exc): | |
| try: | |
| _orig_call_connection_lost(self, exc) | |
| except ConnectionResetError: | |
| pass | |
| except OSError as e: | |
| if getattr(e, 'winerror', None) == 10054: | |
| pass | |
| else: | |
| raise | |
| _ProactorBasePipeTransport._call_connection_lost = _silenced_call_connection_lost | |
| if __name__ == "__main__": | |
| if os.name == 'nt': | |
| try: | |
| set_start_method('spawn') | |
| except RuntimeError as e: | |
| if "context has already been set" not in str(e): | |
| raise | |
| else: | |
| pass | |
| init_database(APP_DB_URL) | |
| db_path_str = APP_DB_URL.replace("sqlite:///", "") | |
| db_path = Path(db_path_str) | |
| is_first_run = not db_path.exists() | |
| if is_first_run: | |
| wizard_script = Path(__file__).resolve().parent / "scripts" / "setup_wizard.py" | |
| if wizard_script.exists(): | |
| python_executable = sys.executable | |
| env = os.environ.copy() | |
| project_root_path = str(Path(__file__).resolve().parent) | |
| current_python_path = env.get("PYTHONPATH", "") | |
| new_python_path = f"{project_root_path}{os.pathsep}{current_python_path}" | |
| env["PYTHONPATH"] = new_python_path | |
| result = subprocess.run([python_executable, str(wizard_script)], env=env) | |
| if result.returncode != 0: | |
| sys.exit(1) | |
| run_one_time_startup_tasks(startup_lock) | |
| db = db_session_module.SessionLocal() | |
| try: | |
| settings.load_from_db(db) | |
| from backend.com_hub import start_hub_server | |
| hub_port_val = settings.get("com_hub_port", SERVER_CONFIG.get("com_hub_port", 8042)) | |
| threading.Thread( | |
| target=start_hub_server, | |
| kwargs={"host": "127.0.0.1", "port": int(hub_port_val)}, | |
| daemon=True | |
| ).start() | |
| host_setting = settings.get("host", SERVER_CONFIG.get("host", "0.0.0.0")) | |
| port_setting = settings.get("port", SERVER_CONFIG.get("port", 9642)) | |
| https_enabled = settings.get("https_enabled", False) | |
| finally: | |
| db.close() | |
| data_dir = Path(settings.get("data_dir", "data")) | |
| (data_dir / "mcps").mkdir(parents=True, exist_ok=True) | |
| (data_dir / "apps").mkdir(parents=True, exist_ok=True) | |
| workers = int(os.getenv("LOLLMS_WORKERS", SERVER_CONFIG.get("workers", 1))) | |
| ssl_params = {} | |
| if settings.get("https_enabled"): | |
| certfile = settings.get("ssl_certfile") | |
| keyfile = settings.get("ssl_keyfile") | |
| try: | |
| if certfile and keyfile and Path(certfile).is_file() and Path(keyfile).is_file(): | |
| ssl_params["ssl_certfile"] = certfile | |
| ssl_params["ssl_keyfile"] = keyfile | |
| else: | |
| raise FileNotFoundError("Certificate or key file is missing.") | |
| except Exception as e: | |
| print(f"WARNING: HTTPS config error: {e}. Server will start without HTTPS.") | |
| content = "" | |
| protocol = "https" if ssl_params else "http" | |
| if host_setting == "0.0.0.0": | |
| from backend.utils import get_accessible_host | |
| accessible_host = get_accessible_host() | |
| if accessible_host != 'localhost': | |
| content += f"[magenta]Recommended public access URL:[/magenta] {protocol}://{accessible_host}:{port_setting}/\n" | |
| content += f"[magenta]Or access locally at:[/magenta] {protocol}://localhost:{port_setting}/\n" | |
| else: | |
| content += f"[magenta]Access UI at:[/magenta] {protocol}://{host_setting}:{port_setting}/\n" | |
| content += f"[green]Using {workers} Workers[/green]" | |
| ASCIIColors.panel(content, f"LoLLMs Platform (v{APP_VERSION})") | |
| from pydantic import BaseModel, Field | |
| from backend.session import get_current_active_user, UserAuthDetails | |
| class GenerateTextRequest(BaseModel): | |
| prompt: str | |
| max_new_tokens: Optional[int] = Field(default=1024, alias="max_new_tokens") | |
| temperature: Optional[float] = 0.2 | |
| async def lollms_generate( | |
| request: GenerateTextRequest, | |
| current_user: UserAuthDetails = Depends(get_current_active_user), | |
| db: Session = Depends(get_db) | |
| ): | |
| try: | |
| user_model_full = current_user.lollms_model_name | |
| binding_alias = None | |
| model_name = None | |
| if user_model_full and '/' in user_model_full: | |
| binding_alias, model_name = user_model_full.split('/', 1) | |
| lc = build_lollms_client_from_params( | |
| username=current_user.username, | |
| binding_alias=binding_alias, | |
| model_name=model_name, | |
| load_llm=True | |
| ) | |
| generated_text = await asyncio.to_thread( | |
| lc.generate_text, | |
| prompt=request.prompt, | |
| n_predict=request.max_new_tokens, | |
| temperature=request.temperature | |
| ) | |
| return {"generated_text": generated_text} | |
| except Exception as e: | |
| trace_exception(e) | |
| raise HTTPException(status_code=500, detail=str(e)) | |
| uvicorn.run("main:app", host=host_setting, port=int(port_setting), reload=False, workers=workers, timeout_keep_alive=600, **ssl_params) |
Xet Storage Details
- Size:
- 32.7 kB
- Xet hash:
- c01e3546a451e8be19ed2200aac80ad93e96e1b919eccff68be1860c9a072579
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.