dtoro
204d2bf2a8
Cleans up the maze of overlapping ways folders entered the app, plus
removes the dead trash plumbing left over from the soft-discard
refactor.
Setup model (now)
- ONE env var: PHOTO_DIRS in .env, set to the host path of your
library. Compose mounts that at /photos. That's the entire setup.
- On first boot, the backend auto-creates a SourceRoot row named
"Library" pointing at /photos so the user sees their photos
immediately without configuring anything.
- Source roots and discard live in the database; mulita.yml only
carries operational settings (thumbnails, scanner, performance).
- The "Add Source Folder" dialog is now a directory browser
restricted server-side to /photos and any existing source root —
the user clicks through actual mounted directories instead of
typing container paths they can't possibly know.
Backend
- New services/scanner.bootstrap_default_source_root(): if no
SourceRoot rows exist and /photos is mounted, create one. Wired
into the lifespan handler before cleanup + initial scan.
- New GET /library/browse?path= returning the immediate child
directories of `path`, validated to live under one of the allowed
roots (default mount + every active SourceRoot). Hidden entries
are filtered. Children are tagged with is_existing_root so the UI
can show an "Added" badge. Returns parent path for up-nav, or
null when at the top of the allowed scope.
- scan_all_source_roots now reads from the DB instead of the YAML
config so DB-managed source roots are honoured by initial scan.
- Dropped the placeholder source_roots block from mulita.yml — the
paths /photos/main and /photos/iphone never existed and just
produced startup warnings.
- Dropped TrashSettings, settings.trash, settings.source_roots,
and the SourceRoot pydantic model from config.py. Soft discard
has owned this for a while; it was dead code.
Compose
- Single ${PHOTO_DIRS:-./photos}:/photos:rw mount in both backend
and worker.
- Removed the hardcoded ~/Pictures:/host/Pictures:rw mount — the
PHOTO_DIRS variable is the single source of truth now.
- Removed the trash_data named volume + mounts (no consumers).
- backend/Dockerfile no longer creates /data/trash; it now creates
/data/proxies (which the proxy endpoint actually uses).
Frontend
- AddSourceFolderDialog rewritten as a directory tree picker:
loads /library/browse on open, lets the user navigate up via a
ChevronUp button or down by clicking subfolders, shows the
current path inline, and adds whatever directory is currently
shown. Existing source roots are tagged "Added" so the user
knows what's already registered. Errors from the backend (e.g.
trying to navigate outside the allowed scope) surface inline.
- New library.browse() helper + BrowseChild / BrowseResponse types
in services/api.ts.
Docs
- README Quick Start rewritten around the single PHOTO_DIRS env
var, with macOS/Linux/Windows examples.
- New "How mounted folders and source folders relate" section that
spells out the two-layer model (mount = visibility, source root
= scanning) so the most common confusion is addressed up front.
- Added a "Read-only libraries" subsection that lists exactly which
endpoints fail under :ro.
- "Configuration" section reframed: source roots are managed by the
UI/API now, mulita.yml is operational settings only.
- .env file now has examples for the common host paths.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
111 lines
3.0 KiB
Python
111 lines
3.0 KiB
Python
"""
|
|
Application configuration using Pydantic Settings
|
|
"""
|
|
from pydantic_settings import BaseSettings
|
|
from pydantic import BaseModel, Field
|
|
from typing import Optional
|
|
import yaml
|
|
from pathlib import Path
|
|
|
|
class ThumbnailSettings(BaseModel):
|
|
"""Thumbnail generation settings"""
|
|
small: int = 240
|
|
medium: int = 640
|
|
large: int = 1280
|
|
quality: int = 85
|
|
format: str = "webp"
|
|
|
|
class ScannerSettings(BaseModel):
|
|
"""File scanner settings"""
|
|
watch: bool = True
|
|
initial_scan_on_start: bool = True
|
|
batch_size: int = 100
|
|
concurrent_workers: int = 4
|
|
|
|
class PerformanceSettings(BaseModel):
|
|
"""Performance tuning settings"""
|
|
max_concurrent_thumbnails: int = 10
|
|
cache_ttl: int = 3600
|
|
db_pool_size: int = 20
|
|
db_pool_recycle: int = 3600
|
|
|
|
class MulitaConfig(BaseModel):
|
|
"""Main configuration from YAML file. Source roots and the discard
|
|
workflow are owned by the database now — only operational settings
|
|
live here."""
|
|
thumbnails: ThumbnailSettings = ThumbnailSettings()
|
|
scanner: ScannerSettings = ScannerSettings()
|
|
performance: PerformanceSettings = PerformanceSettings()
|
|
|
|
class Settings(BaseSettings):
|
|
"""Application settings"""
|
|
# Database
|
|
database_url: str = Field(
|
|
default="sqlite+aiosqlite:///data/db/mulita.db",
|
|
env="DATABASE_URL"
|
|
)
|
|
|
|
# Redis
|
|
redis_url: str = Field(
|
|
default="redis://localhost:6379",
|
|
env="REDIS_URL"
|
|
)
|
|
|
|
# Celery
|
|
celery_broker_url: str = Field(
|
|
default="redis://localhost:6379",
|
|
env="CELERY_BROKER_URL"
|
|
)
|
|
celery_result_backend: str = Field(
|
|
default="redis://localhost:6379",
|
|
env="CELERY_RESULT_BACKEND"
|
|
)
|
|
|
|
# Photo directories
|
|
photo_dirs: str = Field(
|
|
default="/photos",
|
|
env="PHOTO_DIRS"
|
|
)
|
|
|
|
# API settings
|
|
api_host: str = Field(default="0.0.0.0", env="API_HOST")
|
|
api_port: int = Field(default=8000, env="API_PORT")
|
|
|
|
# App configuration from YAML
|
|
_config: Optional[MulitaConfig] = None
|
|
|
|
@property
|
|
def config(self) -> MulitaConfig:
|
|
"""Load configuration from YAML file"""
|
|
if self._config is None:
|
|
config_path = Path("/app/config/mulita.yml")
|
|
if not config_path.exists():
|
|
config_path = Path("mulita.yml")
|
|
|
|
if config_path.exists():
|
|
with open(config_path, "r") as f:
|
|
config_data = yaml.safe_load(f)
|
|
self._config = MulitaConfig(**config_data)
|
|
else:
|
|
self._config = MulitaConfig()
|
|
|
|
return self._config
|
|
|
|
@property
|
|
def thumbnails(self) -> ThumbnailSettings:
|
|
return self.config.thumbnails
|
|
|
|
@property
|
|
def scanner(self) -> ScannerSettings:
|
|
return self.config.scanner
|
|
|
|
@property
|
|
def performance(self) -> PerformanceSettings:
|
|
return self.config.performance
|
|
|
|
class Config:
|
|
env_file = ".env"
|
|
case_sensitive = False
|
|
|
|
# Global settings instance
|
|
settings = Settings() |