681 lines
27 KiB
Python
681 lines
27 KiB
Python
import asyncio
|
|
import sys
|
|
import warnings
|
|
|
|
if sys.platform == "win32" and hasattr(asyncio, "WindowsSelectorEventLoopPolicy"):
|
|
# Avoid noisy Proactor transport resets on long-running Windows sessions.
|
|
with warnings.catch_warnings():
|
|
warnings.simplefilter("ignore", DeprecationWarning)
|
|
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
|
|
|
|
from nicegui import ui, app, run
|
|
from typing import cast
|
|
from pathlib import Path
|
|
from functools import partial
|
|
from datetime import datetime
|
|
|
|
# Add project root to sys.path to allow for absolute imports
|
|
# This is now handled by the run_desktop.py and cli/main.py scripts, but good for linters.
|
|
sys.path.append(str(Path(__file__).resolve().parent.parent.parent))
|
|
from journal.core.entry import (
|
|
create_daily_entry,
|
|
create_deep_entry,
|
|
create_fragment_entry,
|
|
create_recovery_entry,
|
|
)
|
|
from journal.core.storage import (
|
|
save_entry_content,
|
|
load_all_vaults,
|
|
rebuild_all_vaults,
|
|
save_current_month_vault,
|
|
initialize_vault,
|
|
clear_data_directory,
|
|
)
|
|
from journal.core.config import (
|
|
DATA_DIR,
|
|
VAULT_DIR,
|
|
SPEECH_RECOGNITION_ENGINE,
|
|
WHISPER_MODEL_SIZE,
|
|
)
|
|
from journal.core.parser import parse_journal_file
|
|
from journal.ai.analysis import summarize_entry, summarize_all_entries
|
|
from journal.ai.chat import get_cloud_ai_response
|
|
from journal.ui.components.speech import speech_to_text
|
|
from journal.ui.components.calendar import calendar_view
|
|
from journal.ui.components.editor import rich_text_editor
|
|
from journal.ui.components.settings import settings_dialog
|
|
|
|
ui.dark_mode = True
|
|
|
|
|
|
# Global variables
|
|
selected_file_name: str = ""
|
|
drawer: ui.left_drawer | None = None
|
|
main_tab: ui.tabs | None = None
|
|
edit_tab: ui.tab | None = None
|
|
ai_tab: ui.tab | None = None
|
|
new_tab: ui.tab | None = None
|
|
entry_content_box: ui.editor | None = None
|
|
analysis_box: ui.textarea | None = None
|
|
new_entry_box: ui.editor | None = None
|
|
file_map: dict[str, str] = {}
|
|
vault_password: str | None = None # Global to store the password for the shutdown hook
|
|
sidebar_content: ui.column | None = None
|
|
content_container: ui.column | None = None
|
|
# Must be created inside page/layout scope for NiceGUI.
|
|
all_analysis_dialog: ui.dialog | None = None
|
|
vault_load_lock = asyncio.Lock()
|
|
|
|
|
|
def _is_client_active(client: object | None) -> bool:
|
|
return bool(client is not None and getattr(client, "has_socket_connection", False))
|
|
|
|
|
|
def _is_deleted_client_error(error: RuntimeError) -> bool:
|
|
text = str(error).lower()
|
|
return "client this element belongs to has been deleted" in text or "parent slot of the element has been deleted" in text
|
|
|
|
|
|
def list_journal_files():
|
|
# List files directly from the DATA_DIR (which is the decrypted workspace)
|
|
files = sorted(DATA_DIR.glob("*.md"))
|
|
print(f"list_journal_files found: {[f.name for f in files]}")
|
|
return [(f.name, str(f)) for f in files]
|
|
|
|
|
|
def save_entry(content: str, mode: str, password: str | None) -> str:
|
|
# Save to the DATA_DIR, then trigger a vault save
|
|
save_entry_content(content, mode=mode)
|
|
if password:
|
|
save_current_month_vault(password)
|
|
return "Entry saved."
|
|
|
|
|
|
def load_entry(file_path: str) -> str:
|
|
try:
|
|
entry = parse_journal_file(file_path)
|
|
return entry.raw_content
|
|
except Exception as e:
|
|
return f"Error loading file: {e}"
|
|
|
|
|
|
def save_existing_entry(file_path: str, content: str, password: str | None) -> str:
|
|
try:
|
|
# Overwriting is the correct behavior when editing a full, existing entry.
|
|
save_entry_content(content, file_path=Path(file_path), mode="Daily")
|
|
if password:
|
|
save_current_month_vault(password)
|
|
return f"Appended changes to {file_path}"
|
|
except Exception as e:
|
|
return f"Error saving file: {e}"
|
|
|
|
|
|
def analyze_entry(file_path: str) -> str:
|
|
try:
|
|
entry = parse_journal_file(file_path)
|
|
analysis = summarize_entry(entry)
|
|
return analysis
|
|
except Exception as e:
|
|
return f"Error analyzing entry: {e}"
|
|
|
|
|
|
def analyze_all_entries() -> str:
|
|
try:
|
|
journal_files = sorted(DATA_DIR.glob("*.md"))
|
|
if not journal_files:
|
|
return "No journal files found."
|
|
entries = [parse_journal_file(str(f)) for f in journal_files]
|
|
analysis = summarize_all_entries(entries)
|
|
return analysis
|
|
except Exception as e:
|
|
return f"Error analyzing all entries: {e}"
|
|
|
|
|
|
def update_sidebar():
|
|
global \
|
|
file_map, \
|
|
drawer, \
|
|
main_tab, \
|
|
edit_tab, \
|
|
entry_content_box, \
|
|
analysis_box, \
|
|
sidebar_content
|
|
print("update_sidebar called.")
|
|
if sidebar_content:
|
|
try:
|
|
sidebar_content.clear()
|
|
except RuntimeError as error:
|
|
if _is_deleted_client_error(error):
|
|
print("Skipping sidebar update because the client was deleted.")
|
|
return
|
|
raise
|
|
try:
|
|
with sidebar_content:
|
|
_ = ui.label("📅 Calendar").classes("text-md font-bold mb-4")
|
|
|
|
def on_date_select(date: str):
|
|
global selected_file_name
|
|
selected_file_name = f"{date}.md"
|
|
if main_tab is not None and edit_tab is not None:
|
|
main_tab.set_value(edit_tab)
|
|
if entry_content_box is not None:
|
|
entry_content_box.set_value(
|
|
load_entry(file_map[selected_file_name])
|
|
)
|
|
if analysis_box is not None:
|
|
analysis_box.set_value("")
|
|
if drawer:
|
|
drawer.set_value(False)
|
|
|
|
calendar_view(on_select=on_date_select)
|
|
_ = ui.separator().classes("my-4")
|
|
_ = ui.label("📁 Journal Files").classes("text-lg font-bold mb-4")
|
|
|
|
files = list_journal_files()
|
|
file_names = [f[0] for f in files]
|
|
file_map = dict(files)
|
|
print(f"file_map in update_sidebar: {file_map}")
|
|
|
|
def on_file_select(fname: str):
|
|
global selected_file_name
|
|
selected_file_name = fname
|
|
if main_tab is not None and edit_tab is not None:
|
|
main_tab.set_value(edit_tab)
|
|
if entry_content_box is not None:
|
|
entry_content_box.set_value(load_entry(file_map[fname]))
|
|
if analysis_box is not None:
|
|
analysis_box.set_value("")
|
|
if drawer:
|
|
drawer.set_value(False)
|
|
|
|
for fname in file_names:
|
|
_ = (
|
|
ui.button(fname, on_click=partial(on_file_select, fname))
|
|
.classes("w-full justify-start mb-1")
|
|
.props("flat")
|
|
)
|
|
|
|
_ = ui.separator().classes("my-4")
|
|
|
|
def open_new_tab():
|
|
if main_tab is not None and new_tab is not None:
|
|
main_tab.set_value(new_tab)
|
|
if drawer:
|
|
drawer.set_value(False)
|
|
|
|
_ = (
|
|
ui.button("New Entry", on_click=open_new_tab)
|
|
.props("color=primary")
|
|
.classes("w-full mb-2")
|
|
)
|
|
|
|
def open_all_analysis_dialog():
|
|
if all_analysis_dialog is not None:
|
|
all_analysis_dialog.open()
|
|
|
|
_ = (
|
|
ui.button("Analyze All Entries", on_click=open_all_analysis_dialog)
|
|
.props("color=accent")
|
|
.classes("w-full")
|
|
)
|
|
except RuntimeError as error:
|
|
if _is_deleted_client_error(error):
|
|
print("Sidebar update aborted because client elements were deleted.")
|
|
return
|
|
raise
|
|
|
|
|
|
# --- Main UI Layout Function (Inner Content) ---
|
|
def journal_ui_layout():
|
|
global \
|
|
main_tab, \
|
|
edit_tab, \
|
|
ai_tab, \
|
|
new_tab, \
|
|
entry_content_box, \
|
|
analysis_box, \
|
|
new_entry_box
|
|
|
|
# --- Main Content - Full Screen ---
|
|
with ui.element("div").style(
|
|
"width: 100vw; height: calc(100vh - 64px); overflow: hidden; padding: 0; margin: 0;"
|
|
):
|
|
with ui.element("div").style(
|
|
"width: 100%; height: 100%; padding: 16px; box-sizing: border-box; display: flex; flex-direction: column;"
|
|
):
|
|
# Tabs
|
|
with ui.tabs().classes("w-full mb-4") as main_tab_instance:
|
|
global main_tab
|
|
main_tab = main_tab_instance
|
|
edit_tab = ui.tab("Edit Entry")
|
|
ai_tab = ui.tab("AI Analysis")
|
|
chat_tab = ui.tab("AI Chat")
|
|
new_tab = ui.tab("New Entry")
|
|
speech_tab = ui.tab("Speech to Text")
|
|
|
|
# Tab Panels - Full Height
|
|
with ui.tab_panels(main_tab, value=edit_tab).classes(
|
|
"w-full flex-grow bg-gray-800"
|
|
):
|
|
# --- Edit Entry Tab ---
|
|
with ui.tab_panel(edit_tab).style(
|
|
"flex: 1; display: flex; flex-direction: column; padding: 0;"
|
|
):
|
|
entry_content_box = rich_text_editor().classes("w-full h-full")
|
|
|
|
# --- AI Analysis Tab ---
|
|
with ui.tab_panel(ai_tab).style(
|
|
"flex: 1; display: flex; flex-direction: column; padding: 16px;"
|
|
):
|
|
_ = (
|
|
ui.label("AI Analysis")
|
|
.classes("text-xl font-bold mb-4")
|
|
.style("flex-shrink: 0;")
|
|
)
|
|
|
|
analysis_box = (
|
|
ui.textarea(
|
|
label="Analysis Results",
|
|
placeholder='Click "Analyze Entry" to get AI analysis of the selected journal entry...',
|
|
)
|
|
.props("readonly outlined")
|
|
.style("flex: 1; width: 100%; min-height: 0;")
|
|
)
|
|
|
|
with ui.row().classes("gap-4 mt-4").style("flex-shrink: 0;"):
|
|
|
|
async def analyze_selected_wrapper():
|
|
client = ui.context.client
|
|
if (
|
|
selected_file_name
|
|
and selected_file_name in file_map
|
|
and analysis_box is not None
|
|
):
|
|
ui.notify("Analyzing entry...", type="info")
|
|
analysis = await run.io_bound(
|
|
analyze_entry, file_map[selected_file_name]
|
|
)
|
|
if not _is_client_active(client):
|
|
return
|
|
analysis_box.set_value(analysis)
|
|
ui.notify("Analysis complete!", type="positive")
|
|
else:
|
|
ui.notify("No file selected", type="warning")
|
|
|
|
_ = ui.button(
|
|
"Analyze Entry", on_click=analyze_selected_wrapper
|
|
).props("color=primary size=lg")
|
|
|
|
# --- AI Chat Tab ---
|
|
with ui.tab_panel(chat_tab).style(
|
|
"flex: 1; display: flex; flex-direction: column; padding: 16px;"
|
|
):
|
|
_ = (
|
|
ui.label("AI Chat")
|
|
.classes("text-xl font-bold mb-4")
|
|
.style("flex-shrink: 0;")
|
|
)
|
|
|
|
chat_output = (
|
|
ui.textarea(
|
|
label="Chat History",
|
|
placeholder="Chat with the AI...",
|
|
)
|
|
.props("readonly outlined")
|
|
.style("flex: 1; width: 100%; min-height: 0;")
|
|
)
|
|
|
|
chat_input = ui.input(placeholder="Enter your message").style(
|
|
"width: 100%;"
|
|
)
|
|
|
|
async def send_chat_message():
|
|
client = ui.context.client
|
|
chat_value = cast(str | None, chat_input.value)
|
|
if chat_value and chat_output:
|
|
prompt = chat_value
|
|
chat_input.value = ""
|
|
response = await run.io_bound(get_cloud_ai_response, prompt)
|
|
if not _is_client_active(client):
|
|
return
|
|
current_chat = str(
|
|
cast(str | None, chat_output.value) or ""
|
|
)
|
|
chat_output.value = (
|
|
current_chat + f"> {prompt}\n{response}\n"
|
|
)
|
|
|
|
_ = chat_input.on("keydown.enter", send_chat_message)
|
|
|
|
# --- New Entry Tab ---
|
|
with ui.tab_panel(new_tab).style(
|
|
"flex: 1; display: flex; flex-direction: column; padding: 16px;"
|
|
):
|
|
_ = (
|
|
ui.label("Create New Entry")
|
|
.classes("text-xl font-bold mb-4")
|
|
.style("flex-shrink: 0;")
|
|
)
|
|
|
|
mode = (
|
|
ui.select(
|
|
["Daily", "Deep Recovery", "Fragment", "Deep Entry"],
|
|
label="Entry Type",
|
|
value="Daily",
|
|
)
|
|
.classes("mb-4 w-64")
|
|
.style("flex-shrink: 0;")
|
|
)
|
|
|
|
new_entry_box = rich_text_editor()
|
|
|
|
def update_new_entry_box_on_mode_change():
|
|
if new_entry_box is None:
|
|
return # Can't do anything if the box doesn't exist yet
|
|
|
|
mode_val = cast(str | None, mode.value)
|
|
today_file_path = (
|
|
DATA_DIR / f"{datetime.now().strftime('%Y-%m-%d')}.md"
|
|
)
|
|
if (
|
|
mode_val
|
|
and mode_val in ["Daily", "Deep Recovery", "Deep Entry"]
|
|
and today_file_path.exists()
|
|
):
|
|
new_entry_box.set_value(
|
|
today_file_path.read_text(encoding="utf-8")
|
|
)
|
|
ui.notify("Loaded today's existing entry.", type="info")
|
|
else:
|
|
new_entry_box.set_value("")
|
|
|
|
_ = mode.on(
|
|
"update:model-value", update_new_entry_box_on_mode_change
|
|
)
|
|
|
|
with ui.row().classes("gap-4 mt-4").style("flex-shrink: 0;"):
|
|
|
|
def fill_template():
|
|
mode_val = cast(str | None, mode.value)
|
|
if new_entry_box is not None and mode_val is not None:
|
|
template_func = {
|
|
"Daily": create_daily_entry,
|
|
"Deep Recovery": create_recovery_entry,
|
|
"Fragment": create_fragment_entry,
|
|
"Deep Entry": create_deep_entry,
|
|
}[mode_val]
|
|
new_entry_box.set_value(template_func())
|
|
ui.notify("Template loaded!", type="info")
|
|
|
|
async def save_new_wrapper():
|
|
client = ui.context.client
|
|
new_entry_value = cast(
|
|
str | None,
|
|
new_entry_box.value if new_entry_box else None,
|
|
)
|
|
mode_val = cast(str, mode.value)
|
|
password = cast(
|
|
str | None, getattr(app.storage.user, "vault_password", None)
|
|
)
|
|
if new_entry_value and new_entry_value.strip():
|
|
# For new entries, always append to today's file
|
|
msg = await run.io_bound(
|
|
save_entry, new_entry_value, mode_val, password
|
|
)
|
|
if not _is_client_active(client):
|
|
return
|
|
ui.notify(msg, type="positive")
|
|
if new_entry_box:
|
|
new_entry_box.set_value("")
|
|
update_sidebar() # Refresh the sidebar
|
|
else:
|
|
ui.notify("Entry content is empty", type="warning")
|
|
|
|
_ = ui.button("Create Template", on_click=fill_template).props(
|
|
"color=secondary size=lg"
|
|
)
|
|
_ = ui.button("Save Entry", on_click=save_new_wrapper).props(
|
|
"color=primary size=lg"
|
|
)
|
|
# --- Speech to Text Tab ---
|
|
with ui.tab_panel(speech_tab).style(
|
|
"flex: 1; display: flex; flex-direction: column; padding: 16px;"
|
|
):
|
|
# Add a text area to display the live transcription
|
|
speech_output_box = (
|
|
ui.textarea(label="Live Transcription")
|
|
.props("outlined")
|
|
.classes("w-full flex-grow")
|
|
)
|
|
|
|
def on_speech_result(text: str):
|
|
# Append new transcribed text to the speech output box
|
|
current_text = cast(str, speech_output_box.value or "")
|
|
speech_output_box.set_value(current_text + text)
|
|
|
|
# The speech component itself, which now updates the local text area
|
|
with ui.row().classes("w-full justify-between mt-4"):
|
|
speech_to_text(on_result=on_speech_result)
|
|
|
|
def append_to_new_entry():
|
|
# Safely get and cast the value from the speech box to satisfy pyright.
|
|
speech_text = cast(str, speech_output_box.value or "")
|
|
if new_entry_box is not None and speech_text:
|
|
# Append the transcribed text to the main new entry editor
|
|
current_entry_text = cast(
|
|
str, new_entry_box.value or ""
|
|
)
|
|
new_entry_box.set_value(
|
|
current_entry_text + speech_text
|
|
)
|
|
|
|
# Clear the speech box and notify the user
|
|
speech_output_box.set_value("")
|
|
ui.notify(
|
|
"Text appended to 'New Entry' tab.",
|
|
type="positive",
|
|
)
|
|
|
|
_ = ui.button(
|
|
"Append to New Entry", on_click=append_to_new_entry
|
|
).props("color=primary")
|
|
# --- Dialog for "Analyze All Entries" ---
|
|
global all_analysis_dialog
|
|
if all_analysis_dialog is None:
|
|
all_analysis_dialog = ui.dialog()
|
|
|
|
with all_analysis_dialog, ui.card().classes("w-full max-w-5xl max-h-[90vh]"):
|
|
_ = ui.label("Comprehensive Journal Analysis").classes("text-xl font-bold mb-4")
|
|
all_analysis_output = (
|
|
ui.textarea(label="Analysis Results")
|
|
.props("readonly outlined")
|
|
.classes("h-96 mb-4 w-full")
|
|
)
|
|
|
|
with ui.row().classes("gap-4"):
|
|
|
|
async def do_analyze_all_wrapper():
|
|
client = ui.context.client
|
|
ui.notify("Analyzing all entries...", type="info")
|
|
result: str = await run.io_bound(analyze_all_entries)
|
|
if not _is_client_active(client):
|
|
return
|
|
all_analysis_output.set_value(result)
|
|
ui.notify("Analysis complete!", type="positive")
|
|
|
|
_ = ui.button("Run Analysis", on_click=do_analyze_all_wrapper).props(
|
|
"color=primary"
|
|
)
|
|
_ = ui.button("Close", on_click=lambda: all_analysis_dialog.close() if all_analysis_dialog else None).props(
|
|
"color=secondary"
|
|
)
|
|
|
|
|
|
@ui.page("/")
|
|
async def index_page():
|
|
global drawer, sidebar_content, content_container
|
|
_ = ui.query("body").style("background-color: #111827")
|
|
# Top-level layout elements (always present)
|
|
with (
|
|
ui.left_drawer(value=False)
|
|
.props("overlay")
|
|
.classes("w-64 bg-gray-900 text-white") as drawer_instance
|
|
):
|
|
drawer = drawer_instance
|
|
sidebar_content = ui.column().classes("p-4 gap-2 h-full")
|
|
# Sidebar content will be updated after vault load
|
|
|
|
with ui.header(elevated=True).classes(
|
|
"items-center justify-between px-4 bg-gray-900"
|
|
):
|
|
# Add a None check inside the lambda to satisfy the type checker
|
|
_ = ui.button(
|
|
icon="menu", on_click=lambda: drawer.toggle() if drawer else None
|
|
).props("flat color=white")
|
|
_ = ui.label("📓 Project Journal").classes("text-2xl font-bold")
|
|
_ = ui.space()
|
|
# Instantiate and open the settings dialog
|
|
settings = settings_dialog()
|
|
_ = ui.button(icon="settings", on_click=settings.open).props("flat color=white")
|
|
|
|
# Main content area (dynamically populated)
|
|
with ui.column().classes(
|
|
"w-full h-full bg-gray-900 text-white"
|
|
) as content_container_instance:
|
|
content_container = content_container_instance
|
|
if not getattr(app.storage.user, "authenticated", False):
|
|
with ui.card().classes("absolute-center bg-gray-800 text-white"):
|
|
_ = ui.label("Welcome to Your Journal").classes("text-2xl font-bold")
|
|
password_input = (
|
|
ui.input(
|
|
"Enter Vault Password",
|
|
password=True,
|
|
placeholder="Type your password",
|
|
)
|
|
.props("autofocus")
|
|
.on("keydown.enter", lambda: password_button.run_method("click"))
|
|
)
|
|
password_button = ui.button(
|
|
"Load Vault",
|
|
on_click=lambda: process_password(
|
|
cast(str | None, password_input.value)
|
|
),
|
|
)
|
|
else:
|
|
# This branch will be executed if the page reloads and password is already set
|
|
# or if we navigate back to '/' after successful login.
|
|
journal_ui_layout()
|
|
update_sidebar() # Ensure sidebar is populated on reload
|
|
|
|
|
|
async def process_password(password: str | None):
|
|
global vault_password, content_container
|
|
client = ui.context.client
|
|
if not password:
|
|
if _is_client_active(client):
|
|
ui.notify("Password cannot be empty.", type="negative")
|
|
return
|
|
if cast(bool, app.storage.user.get("auth_in_progress", False)):
|
|
if _is_client_active(client):
|
|
ui.notify("Vault load already in progress. Please wait...", type="warning")
|
|
return
|
|
|
|
if vault_load_lock.locked():
|
|
if _is_client_active(client):
|
|
ui.notify("Another vault operation is already in progress. Please wait...", type="warning")
|
|
return
|
|
|
|
app.storage.user["auth_in_progress"] = True
|
|
try:
|
|
async with vault_load_lock:
|
|
# Check if vault is empty to determine if we're setting a new password
|
|
is_new_vault = not any(VAULT_DIR.iterdir())
|
|
|
|
if is_new_vault:
|
|
await run.io_bound(initialize_vault, password)
|
|
if _is_client_active(client):
|
|
ui.notify("New vault initialized!", type="positive")
|
|
vault_password = password
|
|
# Load the newly initialized vault (which will be empty but sets up DATA_DIR)
|
|
_ = await run.io_bound(load_all_vaults, password)
|
|
else:
|
|
# Attempt to load existing vaults
|
|
load_success = await run.io_bound(load_all_vaults, password)
|
|
if not load_success:
|
|
if _is_client_active(client):
|
|
ui.notify("Incorrect password.", type="negative")
|
|
vault_password = None # Reset password if loading fails
|
|
return
|
|
|
|
# Store password globally for shutdown hook, and in session for this client
|
|
if not _is_client_active(client):
|
|
return
|
|
|
|
vault_password = password
|
|
app.storage.user["authenticated"] = True
|
|
app.storage.user["vault_password"] = password
|
|
# Initialize user settings in session storage
|
|
app.storage.user["speech_engine"] = SPEECH_RECOGNITION_ENGINE
|
|
app.storage.user["whisper_model"] = WHISPER_MODEL_SIZE
|
|
ui.notify("Vault loaded successfully!", type="positive")
|
|
|
|
# Clear the password input area and render the main UI
|
|
if content_container is not None:
|
|
try:
|
|
content_container.clear()
|
|
with content_container:
|
|
journal_ui_layout()
|
|
except RuntimeError as error:
|
|
if _is_deleted_client_error(error):
|
|
print("Skipping layout update because the client was deleted.")
|
|
return
|
|
raise
|
|
update_sidebar() # Populate sidebar after vault is loaded
|
|
|
|
except ValueError as e:
|
|
if _is_client_active(client):
|
|
ui.notify(f"Error: {e}", type="negative")
|
|
vault_password = None
|
|
except Exception as e:
|
|
if _is_client_active(client):
|
|
ui.notify(f"Error loading vault: {e}", type="negative")
|
|
vault_password = None # Reset password if loading fails
|
|
finally:
|
|
try:
|
|
app.storage.user["auth_in_progress"] = False
|
|
except RuntimeError:
|
|
# The page may be gone due to refresh/disconnect before callback completion.
|
|
pass
|
|
|
|
|
|
@app.get("/_health")
|
|
def healthcheck() -> dict[str, str]:
|
|
return {"status": "ok"}
|
|
|
|
|
|
def _shutdown_handler():
|
|
"""Handles saving and cleanup on application exit."""
|
|
print("NiceGUI shutdown hook triggered.")
|
|
if vault_password:
|
|
rebuild_all_vaults(vault_password)
|
|
else:
|
|
print("Vault password is None, skipping save.")
|
|
clear_data_directory()
|
|
|
|
|
|
def main():
|
|
ui.run(
|
|
title="Project Journal",
|
|
reload=False,
|
|
host="0.0.0.0",
|
|
port=8080,
|
|
show=False,
|
|
storage_secret="a_secret_key_for_session_storage",
|
|
)
|
|
|
|
|
|
app.on_shutdown(_shutdown_handler) # pyright: ignore[reportUnknownMemberType]
|
|
|
|
if __name__ in {"__main__", "__mp_main__"}:
|
|
main()
|