arrayview 0.33.0__tar.gz → 0.34.0__tar.gz

{arrayview-0.33.0 → arrayview-0.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrayview
-Version: 0.33.0
+Version: 0.34.0
 Summary: Fast multi-dimensional array viewer
 Project-URL: Home, https://github.com/oscarvanderheide/arrayview
 Project-URL: Source, https://github.com/oscarvanderheide/arrayview

{arrayview-0.33.0 → arrayview-0.34.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arrayview"
-version = "0.33.0"
+version = "0.34.0"
 description = "Fast multi-dimensional array viewer"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12"

arrayview-0.34.0/src/arrayview/_config.py

@@ -0,0 +1,352 @@
+"""Read/write ~/.arrayview/config.toml for persistent user preferences."""
+
+from __future__ import annotations
+
+import datetime as _datetime
+import math
+import os
+import tempfile
+import threading
+from copy import deepcopy
+
+CONFIG_PATH = os.path.expanduser("~/.arrayview/config.toml")
+
+_VALID_WINDOW_MODES = {"browser", "vscode", "native", "inline", "none"}
+_VALID_ENV_KEYS = {"default", "terminal", "vscode", "jupyter", "ssh", "julia"}
+_VALID_THEMES = {"dark", "light"}
+_VALID_ORTHO_LAYOUTS = {"horizontal", "big-left"}
+_VALID_DIMBAR_MODES = {"compact", "extended"}
+_CONFIG_LOCK = threading.Lock()
+
+WINDOW_PREFERENCE_OPTIONS = {
+    "default": ["native", "browser", "none"],
+    "terminal": ["native", "browser", "none"],
+    "vscode": ["vscode", "browser", "native", "none"],
+    "jupyter": ["inline", "browser", "native", "none"],
+    "ssh": ["browser", "none"],
+    "julia": ["browser", "native", "none"],
+}
+BUILTIN_PREFERENCES = {
+    "window": {
+        "default": "native",
+        "terminal": "native",
+        "vscode": "vscode",
+        "jupyter": "inline",
+        "ssh": "browser",
+        "julia": "browser",
+    },
+    "viewer": {
+        "theme": "dark",
+        "rounded_panes": True,
+        "ortho_layout": None,
+        "dimbar_mode": "compact",
+    },
+}
+PREFERENCE_SCHEMA = {
+    "window": WINDOW_PREFERENCE_OPTIONS,
+    "viewer": {
+        "theme": sorted(_VALID_THEMES),
+        "rounded_panes": "boolean",
+        "colormaps": "non-empty list of names",
+        "ortho_layout": sorted(_VALID_ORTHO_LAYOUTS),
+        "dimbar_mode": sorted(_VALID_DIMBAR_MODES),
+    },
+    "nninteractive": {"url": "string"},
+}
+
+
+class MalformedConfigError(ValueError):
+    """Raised when an update would overwrite an unreadable config file."""
+
+
+class InvalidPreferenceError(ValueError):
+    """Raised when an update contains an unknown or invalid preference."""
+
+
+def _load_config_strict() -> dict:
+    if not os.path.isfile(CONFIG_PATH):
+        return {}
+    try:
+        with open(CONFIG_PATH, encoding="utf-8") as f:
+            parsed = _parse_toml(f.read())
+    except Exception as exc:
+        raise MalformedConfigError("The existing config.toml is malformed") from exc
+    if not isinstance(parsed, dict):
+        raise MalformedConfigError("The existing config.toml is not a TOML table")
+    return parsed
+
+
+def load_config() -> dict:
+    """Load config from TOML file. Returns {} on missing/malformed file."""
+    try:
+        return _load_config_strict()
+    except MalformedConfigError:
+        return {}
+
+
+def save_config(config: dict) -> None:
+    """Atomically write a config dict to its TOML file."""
+    folder = os.path.dirname(CONFIG_PATH)
+    if folder:
+        os.makedirs(folder, exist_ok=True)
+    payload = _dump_toml(config)
+    fd, temp_path = tempfile.mkstemp(prefix=".config.", suffix=".tmp", dir=folder or ".")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as f:
+            f.write(payload)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(temp_path, CONFIG_PATH)
+    except Exception:
+        try:
+            os.unlink(temp_path)
+        except FileNotFoundError:
+            pass
+        raise
+
+
+def _normalized_string(value, allowed: set[str], label: str) -> str:
+    if not isinstance(value, str) or value.strip().lower() not in allowed:
+        raise InvalidPreferenceError(f"{label} must be one of: {', '.join(sorted(allowed))}")
+    return value.strip().lower()
+
+
+def _validate_preference(section: str, key: str, value):
+    if section == "window" and key in _VALID_ENV_KEYS:
+        return _normalized_string(
+            value, set(WINDOW_PREFERENCE_OPTIONS[key]), f"window.{key}"
+        )
+    if section == "viewer" and key == "theme":
+        return _normalized_string(value, _VALID_THEMES, "viewer.theme")
+    if section == "viewer" and key == "rounded_panes":
+        if not isinstance(value, bool):
+            raise InvalidPreferenceError("viewer.rounded_panes must be a boolean")
+        return value
+    if section == "viewer" and key == "colormaps":
+        if (
+            not isinstance(value, list)
+            or not value
+            or not all(isinstance(item, str) and item.strip() for item in value)
+        ):
+            raise InvalidPreferenceError("viewer.colormaps must be a non-empty list of names")
+        normalized = [item.strip() for item in value]
+        if len(set(normalized)) != len(normalized):
+            raise InvalidPreferenceError("viewer.colormaps must not contain duplicates")
+        return normalized
+    if section == "viewer" and key == "ortho_layout":
+        return _normalized_string(value, _VALID_ORTHO_LAYOUTS, "viewer.ortho_layout")
+    if section == "viewer" and key == "dimbar_mode":
+        return _normalized_string(value, _VALID_DIMBAR_MODES, "viewer.dimbar_mode")
+    if section == "nninteractive" and key == "url":
+        if not isinstance(value, str) or not value.strip():
+            raise InvalidPreferenceError("nninteractive.url must be a non-empty string")
+        return value.strip()
+    raise InvalidPreferenceError(f"Unknown preference: {section}.{key}")
+
+
+def update_preferences(changes: dict) -> dict:
+    """Validate and merge preferences into the latest config on disk.
+
+    ``None`` removes a known preference, restoring its built-in default.
+    Unknown config sections and keys already on disk are preserved.
+    """
+    if not isinstance(changes, dict) or not changes:
+        raise InvalidPreferenceError("Preference changes must be a non-empty object")
+    validated: dict[str, dict] = {}
+    for section, values in changes.items():
+        if section not in PREFERENCE_SCHEMA or not isinstance(values, dict):
+            raise InvalidPreferenceError(f"Unknown preference section: {section}")
+        if not values:
+            raise InvalidPreferenceError(f"Preference section is empty: {section}")
+        validated[section] = {}
+        for key, value in values.items():
+            if key not in PREFERENCE_SCHEMA[section]:
+                raise InvalidPreferenceError(f"Unknown preference: {section}.{key}")
+            validated[section][key] = None if value is None else _validate_preference(section, key, value)
+
+    with _CONFIG_LOCK:
+        config = _load_config_strict()
+        merged = deepcopy(config)
+        for section, values in validated.items():
+            target = merged.get(section)
+            if target is None:
+                target = {}
+                merged[section] = target
+            if not isinstance(target, dict):
+                raise MalformedConfigError(f"Config section [{section}] is not a table")
+            for key, value in values.items():
+                if value is None:
+                    target.pop(key, None)
+                else:
+                    target[key] = value
+            if not target:
+                merged.pop(section, None)
+        save_config(merged)
+        return merged
+
+
+def get_preferences() -> dict:
+    """Return only supported preferences currently present in the config."""
+    config = load_config()
+    result: dict[str, dict] = {}
+    for section, keys in PREFERENCE_SCHEMA.items():
+        source = config.get(section)
+        if not isinstance(source, dict):
+            continue
+        selected = {key: source[key] for key in keys if key in source}
+        if selected:
+            result[section] = selected
+    return result
+
+
+def get_viewer_colormaps() -> list[str] | None:
+    """Return user-configured colormap cycle list, or None if not configured."""
+    viewer_cfg = load_config().get("viewer", {})
+    if not isinstance(viewer_cfg, dict):
+        return None
+    colormaps = viewer_cfg.get("colormaps")
+    if isinstance(colormaps, list) and all(isinstance(c, str) for c in colormaps) and colormaps:
+        return colormaps
+    return None
+
+
+def get_viewer_theme() -> str | None:
+    """Return user-configured default theme name, or None if not configured."""
+    viewer_cfg = load_config().get("viewer", {})
+    if not isinstance(viewer_cfg, dict):
+        return None
+    theme = viewer_cfg.get("theme")
+    if isinstance(theme, str) and theme.strip().lower() in _VALID_THEMES:
+        return theme.strip().lower()
+    return None
+
+
+def get_viewer_rounded_panes() -> bool | None:
+    """Return user-configured default for rounded panes, or None if not configured."""
+    viewer_cfg = load_config().get("viewer", {})
+    if not isinstance(viewer_cfg, dict):
+        return None
+    val = viewer_cfg.get("rounded_panes")
+    if isinstance(val, bool):
+        return val
+    if isinstance(val, str):
+        s = val.strip().lower()
+        if s in ("true", "1", "yes", "on"):
+            return True
+        if s in ("false", "0", "no", "off"):
+            return False
+    return None
+
+
+def get_viewer_ortho_layout() -> str | None:
+    """Return the preferred initial ortho-view layout."""
+    viewer_cfg = load_config().get("viewer", {})
+    if not isinstance(viewer_cfg, dict):
+        return None
+    value = viewer_cfg.get("ortho_layout")
+    return value.strip().lower() if isinstance(value, str) and value.strip().lower() in _VALID_ORTHO_LAYOUTS else None
+
+
+def get_viewer_dimbar_mode() -> str | None:
+    """Return the preferred initial dimbar mode."""
+    viewer_cfg = load_config().get("viewer", {})
+    if not isinstance(viewer_cfg, dict):
+        return None
+    value = viewer_cfg.get("dimbar_mode")
+    return value.strip().lower() if isinstance(value, str) and value.strip().lower() in _VALID_DIMBAR_MODES else None
+
+
+def get_nninteractive_url() -> str | None:
+    """Return configured nnInteractive server URL, or None."""
+    env_val = os.environ.get("ARRAYVIEW_NNINTERACTIVE_URL", "").strip()
+    if env_val:
+        return env_val
+    nn_cfg = load_config().get("nninteractive", {})
+    if isinstance(nn_cfg, dict):
+        url = nn_cfg.get("url")
+        if isinstance(url, str) and url.strip():
+            return url.strip()
+    return None
+
+
+def get_window_default(environment: str) -> str | None:
+    """Return the user's preferred window mode for the given environment."""
+    env_val = os.environ.get("ARRAYVIEW_WINDOW", "").strip().lower()
+    if env_val:
+        return env_val if env_val in _VALID_WINDOW_MODES else None
+    window_cfg = load_config().get("window", {})
+    if not isinstance(window_cfg, dict):
+        return None
+    val = window_cfg.get(environment) or window_cfg.get("default")
+    if isinstance(val, str) and val.strip().lower() in _VALID_WINDOW_MODES:
+        return val.strip().lower()
+    return None
+
+
+def _parse_toml(text: str) -> dict:
+    import tomllib
+
+    return tomllib.loads(text)
+
+
+def _toml_key(value: str) -> str:
+    if value and all(
+        char in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-"
+        for char in value
+    ):
+        return value
+    return _toml_string(value)
+
+
+def _toml_string(value: str) -> str:
+    escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+    escaped = escaped.replace("\b", "\\b").replace("\t", "\\t").replace("\n", "\\n")
+    escaped = escaped.replace("\f", "\\f").replace("\r", "\\r")
+    return f'"{escaped}"'
+
+
+def _toml_value(value) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, str):
+        return _toml_string(value)
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, float):
+        if not math.isfinite(value):
+            return str(value).lower()
+        return repr(value)
+    if isinstance(value, (_datetime.datetime, _datetime.date, _datetime.time)):
+        return value.isoformat()
+    if isinstance(value, list):
+        return "[" + ", ".join(_toml_value(item) for item in value) + "]"
+    raise TypeError(f"Unsupported TOML value type: {type(value).__name__}")
+
+
+def _dump_toml(config: dict) -> str:
+    """Serialize nested dictionaries and scalar/list TOML values."""
+    lines: list[str] = []
+
+    def emit_table(path: tuple[str, ...], table: dict) -> None:
+        scalar_items = [(key, value) for key, value in table.items() if not isinstance(value, dict)]
+        child_items = [(key, value) for key, value in table.items() if isinstance(value, dict)]
+        if path:
+            lines.append("[" + ".".join(_toml_key(part) for part in path) + "]")
+        for key, value in scalar_items:
+            lines.append(f"{_toml_key(str(key))} = {_toml_value(value)}")
+        if path and (scalar_items or not child_items):
+            lines.append("")
+        for key, value in child_items:
+            emit_table((*path, str(key)), value)
+
+    if not isinstance(config, dict):
+        raise TypeError("Config must be a dictionary")
+    root_scalars = {key: value for key, value in config.items() if not isinstance(value, dict)}
+    root_tables = {key: value for key, value in config.items() if isinstance(value, dict)}
+    for key, value in root_scalars.items():
+        lines.append(f"{_toml_key(str(key))} = {_toml_value(value)}")
+    if root_scalars and root_tables:
+        lines.append("")
+    for key, value in root_tables.items():
+        emit_table((str(key),), value)
+    return "\n".join(lines).rstrip() + ("\n" if lines else "")

{arrayview-0.33.0 → arrayview-0.34.0}/src/arrayview/_instance_registry.py

@@ -9,8 +9,6 @@ from __future__ import annotations
 from contextlib import contextmanager
 from dataclasses import asdict, dataclass
 import ctypes
-import getpass
-import hashlib
 import json
 import os
 from pathlib import Path
@@ -70,9 +68,9 @@ def runtime_directory() -> Path:
     base = os.environ.get("XDG_RUNTIME_DIR")
     if base:
         return Path(base) / "arrayview"
-    user = getpass.getuser().encode("utf-8", "replace")
-    suffix = hashlib.sha256(user).hexdigest()[:12]
-    return Path(tempfile.gettempdir()) / f"arrayview-{suffix}"
+    if hasattr(os, "getuid"):
+        return Path(tempfile.gettempdir()) / f"arrayview-{os.getuid()}"
+    return Path(tempfile.gettempdir()) / f"arrayview-{os.getpid()}"
 
 
 def process_start_identity(pid: int) -> str | None:

{arrayview-0.33.0 → arrayview-0.34.0}/src/arrayview/_launch_plan.py

@@ -132,6 +132,7 @@ class ServerSnapshot:
     server_process_start: str | None = None
     server_capabilities: tuple[str, ...] = ()
     server_protocol_version: str | None = None
+    server_uid: int | None = None
 
 
 @dataclass(frozen=True)
@@ -635,6 +636,7 @@ def _server_snapshot(port: int) -> ServerSnapshot:
         port_busy=_port_busy(port),
         arrayview_server_alive=payload is not None,
         server_pid=_int_or_none(payload.get("pid")) if payload else None,
+        server_uid=_int_or_none(payload.get("uid")) if payload else None,
         server_hostname=_str_or_none(payload.get("hostname")) if payload else None,
         server_instance_id=(
             _str_or_none(payload.get("instance_id")) if payload else None
@@ -658,8 +660,14 @@ def _server_snapshot(port: int) -> ServerSnapshot:
 
 
 def _server_reusable(server: ServerSnapshot) -> bool:
+    same_user = (
+        server.server_uid == os.geteuid()
+        if hasattr(os, "geteuid")
+        else True
+    )
     return (
         server.arrayview_server_alive
+        and same_user
         and server.server_instance_id is not None
         and server.server_protocol_version == "1"
         and "identity-fenced-load" in server.server_capabilities

{arrayview-0.33.0 → arrayview-0.34.0}/src/arrayview/_launcher.py

@@ -111,8 +111,13 @@ def _register_server_runtime(port: int, owner_mode: str):
     from arrayview._instance_registry import InstanceRecord, InstanceRegistry
 
     registry = InstanceRegistry()
+    registry._prepare()
     log_directory = registry.directory / "logs"
-    log_directory.mkdir(parents=True, exist_ok=True)
+    log_directory.mkdir(parents=True, exist_ok=True, mode=0o700)
+    try:
+        os.chmod(log_directory, 0o700)
+    except OSError:
+        pass
     record = InstanceRecord.create(
         port=port,
         protocol_version=_server_mod().SERVER_PROTOCOL_VERSION,

arrayview-0.34.0/src/arrayview/_routes_preferences.py

@@ -0,0 +1,114 @@
+"""Routes for reading and updating persistent user preferences."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+import os
+
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+from arrayview._config import (
+    BUILTIN_PREFERENCES,
+    InvalidPreferenceError,
+    MalformedConfigError,
+    PREFERENCE_SCHEMA,
+    get_preferences,
+    update_preferences,
+)
+import arrayview._session as _session_mod
+from arrayview._session import SESSIONS
+
+
+def _response_payload() -> dict:
+    defaults = deepcopy(BUILTIN_PREFERENCES)
+    schema = deepcopy(PREFERENCE_SCHEMA)
+    for key, options in schema["window"].items():
+        schema["window"][key] = [value for value in options if value != "none"]
+    schema["window"].pop("default", None)
+    try:
+        from arrayview._platform import _is_vscode_remote, _native_window_gui
+
+        native_available = _native_window_gui() is not None
+        vscode_remote = _is_vscode_remote()
+    except Exception:
+        native_available = False
+        vscode_remote = False
+    if not native_available:
+        defaults["window"]["default"] = "browser"
+        defaults["window"]["terminal"] = "browser"
+        for key in ("default", "terminal", "vscode", "jupyter", "julia"):
+            schema["window"][key] = [
+                value for value in schema["window"][key] if value != "native"
+            ]
+    if vscode_remote:
+        schema["window"]["vscode"] = ["vscode", "none"]
+
+    overrides = {}
+    if os.environ.get("ARRAYVIEW_WINDOW", "").strip():
+        overrides["window"] = "ARRAYVIEW_WINDOW"
+    if os.environ.get("ARRAYVIEW_NNINTERACTIVE_URL", "").strip():
+        overrides["nninteractive.url"] = "ARRAYVIEW_NNINTERACTIVE_URL"
+    return {
+        "preferences": get_preferences(),
+        "defaults": defaults,
+        "schema": schema,
+        "overrides": overrides,
+        "server_instance_id": _session_mod.SERVER_RUNTIME.instance_id,
+    }
+
+
+def register_preferences_routes(app) -> None:
+    @app.get("/preferences/{sid}")
+    async def preferences_get(sid: str):
+        if SESSIONS.get(sid) is None:
+            return JSONResponse({"error": "session_not_found"}, status_code=404)
+        return _response_payload()
+
+    @app.patch("/preferences/{sid}")
+    async def preferences_patch(sid: str, request: Request):
+        if SESSIONS.get(sid) is None:
+            return JSONResponse({"error": "session_not_found"}, status_code=404)
+        content_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
+        if content_type != "application/json":
+            return JSONResponse({"error": "json_content_type_required"}, status_code=415)
+        if request.headers.get("x-arrayview-preferences") != "1":
+            return JSONResponse({"error": "preferences_header_required"}, status_code=403)
+        try:
+            body = await request.json()
+        except Exception:
+            return JSONResponse({"error": "invalid_json"}, status_code=400)
+        if not isinstance(body, dict):
+            return JSONResponse({"error": "invalid_json"}, status_code=400)
+        if body.get("server_instance_id") != _session_mod.SERVER_RUNTIME.instance_id:
+            return JSONResponse({"error": "stale_server_instance"}, status_code=409)
+        changes = body.get("changes")
+        try:
+            viewer_changes = changes.get("viewer", {}) if isinstance(changes, dict) else {}
+            colormaps = viewer_changes.get("colormaps")
+            if colormaps is not None:
+                from arrayview._render import _ensure_lut
+
+                invalid = [
+                    name for name in colormaps
+                    if not isinstance(name, str) or not _ensure_lut(name)
+                ]
+                if invalid:
+                    raise InvalidPreferenceError(f"Unknown colormap: {invalid[0]}")
+            update_preferences(changes)
+        except InvalidPreferenceError as exc:
+            return JSONResponse(
+                {"error": "invalid_preference", "detail": str(exc)},
+                status_code=422,
+            )
+        except MalformedConfigError as exc:
+            return JSONResponse(
+                {"error": "malformed_config", "detail": str(exc)},
+                status_code=409,
+            )
+        except OSError as exc:
+            return JSONResponse(
+                {"error": "config_write_failed", "detail": str(exc)},
+                status_code=500,
+            )
+        return _response_payload()

{arrayview-0.33.0 → arrayview-0.34.0}/src/arrayview/_server.py

@@ -41,6 +41,7 @@ from arrayview._routes_analysis import register_analysis_routes
 from arrayview._routes_loading import register_loading_routes
 from arrayview._routes_drop import register_drop_routes
 from arrayview._routes_persistence import register_persistence_routes
+from arrayview._routes_preferences import register_preferences_routes
 from arrayview._routes_export import register_export_routes
 from arrayview._routes_preload import register_preload_routes
 from arrayview._routes_query import register_query_routes
@@ -49,7 +50,13 @@ from arrayview._routes_segmentation import register_segmentation_routes
 from arrayview._routes_state import register_state_routes
 from arrayview._routes_vectorfield import register_vectorfield_routes
 from arrayview._routes_websocket import _notify_shells, register_websocket_routes
-from arrayview._config import get_viewer_colormaps, get_viewer_rounded_panes, get_viewer_theme
+from arrayview._config import (
+    get_viewer_colormaps,
+    get_viewer_dimbar_mode,
+    get_viewer_ortho_layout,
+    get_viewer_rounded_panes,
+    get_viewer_theme,
+)
 
 
 from arrayview._imaging import ensure_image as _pil_image, ensure_imageops as _pil_imageops
@@ -176,6 +183,7 @@ register_websocket_routes(app)
 register_loading_routes(app, notify_shells=_notify_shells, setup_rgb=_setup_rgb)
 register_drop_routes(app)
 register_persistence_routes(app)
+register_preferences_routes(app)
 register_segmentation_routes(app, get_session_or_404)
 register_state_routes(app, get_session_or_404)
 register_export_routes(app, get_session_or_404=get_session_or_404, pil_image=_pil_image)
@@ -228,6 +236,7 @@ def ping():
         "ok": True,
         "service": "arrayview",
         "pid": os.getpid(),
+        "uid": os.geteuid() if hasattr(os, "geteuid") else None,
         "hostname": socket.gethostname(),
         "protocol_version": runtime.protocol_version,
         "package_version": _av_version,
@@ -286,12 +295,19 @@ def get_ui(sid: str = None):
         query_val = "null"
     _init_luts()
     _cfg_colormaps = get_viewer_colormaps()
-    _active_colormaps = _cfg_colormaps if _cfg_colormaps is not None else COLORMAPS
+    _valid_cfg_colormaps = (
+        [name for name in _cfg_colormaps if _ensure_lut(name)]
+        if _cfg_colormaps is not None
+        else []
+    )
+    _active_colormaps = _valid_cfg_colormaps or COLORMAPS
     _theme_names = ["dark", "light"]
     _cfg_theme = get_viewer_theme()
     _default_theme_idx = _theme_names.index(_cfg_theme) if _cfg_theme in _theme_names else 0
     _cfg_rounded = get_viewer_rounded_panes()
     _default_rounded_panes = "false" if _cfg_rounded is False else "true"
+    _default_ortho_layout = json.dumps(get_viewer_ortho_layout())
+    _default_dimbar_mode = json.dumps(get_viewer_dimbar_mode())
     html = (
         _VIEWER_HTML_TEMPLATE.replace("__COLORMAPS__", str(_active_colormaps))
         .replace("__COLORMAP_GRADIENT_STOPS__", json.dumps(COLORMAP_GRADIENT_STOPS))
@@ -301,6 +317,8 @@ def get_ui(sid: str = None):
         .replace("__ARRAYVIEW_QUERY__", query_val)
         .replace("__DEFAULT_THEME_IDX__", str(_default_theme_idx))
         .replace("__DEFAULT_ROUNDED_PANES__", _default_rounded_panes)
+        .replace("__DEFAULT_ORTHO_LAYOUT__", _default_ortho_layout)
+        .replace("__DEFAULT_DIMBAR_MODE__", _default_dimbar_mode)
         .replace("__BODY_CLASS__", "av-loading" if sid else "")
         .replace("__ARRAYVIEW_VERSION__", _av_version)
     )