481 lines
17 KiB
Python
481 lines
17 KiB
Python
"""Data coordinator for Immich Album Watcher."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from dataclasses import dataclass, field
|
|
from datetime import datetime, timedelta
|
|
from typing import Any
|
|
|
|
import aiohttp
|
|
|
|
from homeassistant.core import HomeAssistant
|
|
from homeassistant.helpers.aiohttp_client import async_get_clientsession
|
|
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
|
|
|
|
from .const import (
|
|
ASSET_TYPE_IMAGE,
|
|
ASSET_TYPE_VIDEO,
|
|
ATTR_ADDED_ASSETS,
|
|
ATTR_ADDED_COUNT,
|
|
ATTR_ALBUM_ID,
|
|
ATTR_ALBUM_NAME,
|
|
ATTR_ALBUM_URL,
|
|
ATTR_ASSET_CREATED,
|
|
ATTR_ASSET_FILENAME,
|
|
ATTR_ASSET_OWNER,
|
|
ATTR_ASSET_OWNER_ID,
|
|
ATTR_ASSET_TYPE,
|
|
ATTR_ASSET_URL,
|
|
ATTR_CHANGE_TYPE,
|
|
ATTR_PEOPLE,
|
|
ATTR_REMOVED_ASSETS,
|
|
ATTR_REMOVED_COUNT,
|
|
DOMAIN,
|
|
EVENT_ALBUM_CHANGED,
|
|
EVENT_ASSETS_ADDED,
|
|
EVENT_ASSETS_REMOVED,
|
|
)
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
|
|
@dataclass
|
|
class AssetInfo:
|
|
"""Data class for asset information."""
|
|
|
|
id: str
|
|
type: str # IMAGE or VIDEO
|
|
filename: str
|
|
created_at: str
|
|
owner_id: str = ""
|
|
owner_name: str = ""
|
|
people: list[str] = field(default_factory=list)
|
|
|
|
@classmethod
|
|
def from_api_response(
|
|
cls, data: dict[str, Any], users_cache: dict[str, str] | None = None
|
|
) -> AssetInfo:
|
|
"""Create AssetInfo from API response."""
|
|
people = []
|
|
if "people" in data:
|
|
people = [p.get("name", "") for p in data["people"] if p.get("name")]
|
|
|
|
owner_id = data.get("ownerId", "")
|
|
owner_name = ""
|
|
if users_cache and owner_id:
|
|
owner_name = users_cache.get(owner_id, "")
|
|
|
|
return cls(
|
|
id=data["id"],
|
|
type=data.get("type", ASSET_TYPE_IMAGE),
|
|
filename=data.get("originalFileName", ""),
|
|
created_at=data.get("fileCreatedAt", ""),
|
|
owner_id=owner_id,
|
|
owner_name=owner_name,
|
|
people=people,
|
|
)
|
|
|
|
|
|
@dataclass
|
|
class AlbumData:
|
|
"""Data class for album information."""
|
|
|
|
id: str
|
|
name: str
|
|
asset_count: int
|
|
photo_count: int
|
|
video_count: int
|
|
created_at: str
|
|
updated_at: str
|
|
shared: bool
|
|
owner: str
|
|
thumbnail_asset_id: str | None
|
|
asset_ids: set[str] = field(default_factory=set)
|
|
assets: dict[str, AssetInfo] = field(default_factory=dict)
|
|
people: set[str] = field(default_factory=set)
|
|
has_new_assets: bool = False
|
|
last_change_time: datetime | None = None
|
|
|
|
@classmethod
|
|
def from_api_response(
|
|
cls, data: dict[str, Any], users_cache: dict[str, str] | None = None
|
|
) -> AlbumData:
|
|
"""Create AlbumData from API response."""
|
|
assets_data = data.get("assets", [])
|
|
asset_ids = set()
|
|
assets = {}
|
|
people = set()
|
|
photo_count = 0
|
|
video_count = 0
|
|
|
|
for asset_data in assets_data:
|
|
asset = AssetInfo.from_api_response(asset_data, users_cache)
|
|
asset_ids.add(asset.id)
|
|
assets[asset.id] = asset
|
|
people.update(asset.people)
|
|
if asset.type == ASSET_TYPE_IMAGE:
|
|
photo_count += 1
|
|
elif asset.type == ASSET_TYPE_VIDEO:
|
|
video_count += 1
|
|
|
|
return cls(
|
|
id=data["id"],
|
|
name=data.get("albumName", "Unnamed"),
|
|
asset_count=data.get("assetCount", len(asset_ids)),
|
|
photo_count=photo_count,
|
|
video_count=video_count,
|
|
created_at=data.get("createdAt", ""),
|
|
updated_at=data.get("updatedAt", ""),
|
|
shared=data.get("shared", False),
|
|
owner=data.get("owner", {}).get("name", "Unknown"),
|
|
thumbnail_asset_id=data.get("albumThumbnailAssetId"),
|
|
asset_ids=asset_ids,
|
|
assets=assets,
|
|
people=people,
|
|
)
|
|
|
|
|
|
@dataclass
|
|
class AlbumChange:
|
|
"""Data class for album changes."""
|
|
|
|
album_id: str
|
|
album_name: str
|
|
change_type: str
|
|
added_count: int = 0
|
|
removed_count: int = 0
|
|
added_assets: list[AssetInfo] = field(default_factory=list)
|
|
removed_asset_ids: list[str] = field(default_factory=list)
|
|
|
|
|
|
class ImmichAlbumWatcherCoordinator(DataUpdateCoordinator[dict[str, AlbumData]]):
|
|
"""Coordinator for fetching Immich album data."""
|
|
|
|
def __init__(
|
|
self,
|
|
hass: HomeAssistant,
|
|
url: str,
|
|
api_key: str,
|
|
album_ids: list[str],
|
|
scan_interval: int,
|
|
) -> None:
|
|
"""Initialize the coordinator."""
|
|
super().__init__(
|
|
hass,
|
|
_LOGGER,
|
|
name=DOMAIN,
|
|
update_interval=timedelta(seconds=scan_interval),
|
|
)
|
|
self._url = url.rstrip("/")
|
|
self._api_key = api_key
|
|
self._album_ids = album_ids
|
|
self._previous_states: dict[str, AlbumData] = {}
|
|
self._session: aiohttp.ClientSession | None = None
|
|
self._people_cache: dict[str, str] = {} # person_id -> name
|
|
self._users_cache: dict[str, str] = {} # user_id -> name
|
|
self._shared_links_cache: dict[str, str] = {} # album_id -> share_key
|
|
|
|
@property
|
|
def immich_url(self) -> str:
|
|
"""Return the Immich URL."""
|
|
return self._url
|
|
|
|
@property
|
|
def api_key(self) -> str:
|
|
"""Return the API key."""
|
|
return self._api_key
|
|
|
|
def update_config(self, album_ids: list[str], scan_interval: int) -> None:
|
|
"""Update configuration."""
|
|
self._album_ids = album_ids
|
|
self.update_interval = timedelta(seconds=scan_interval)
|
|
|
|
async def async_refresh_now(self) -> None:
|
|
"""Force an immediate refresh."""
|
|
await self.async_request_refresh()
|
|
|
|
async def async_get_recent_assets(
|
|
self, album_id: str, count: int = 10
|
|
) -> list[dict[str, Any]]:
|
|
"""Get recent assets from an album."""
|
|
if self.data is None or album_id not in self.data:
|
|
return []
|
|
|
|
album = self.data[album_id]
|
|
# Sort assets by created_at descending
|
|
sorted_assets = sorted(
|
|
album.assets.values(),
|
|
key=lambda a: a.created_at,
|
|
reverse=True,
|
|
)[:count]
|
|
|
|
return [
|
|
{
|
|
"id": asset.id,
|
|
"type": asset.type,
|
|
"filename": asset.filename,
|
|
"created_at": asset.created_at,
|
|
"people": asset.people,
|
|
"thumbnail_url": f"{self._url}/api/assets/{asset.id}/thumbnail",
|
|
}
|
|
for asset in sorted_assets
|
|
]
|
|
|
|
async def async_fetch_people(self) -> dict[str, str]:
|
|
"""Fetch all people from Immich."""
|
|
if self._session is None:
|
|
self._session = async_get_clientsession(self.hass)
|
|
|
|
headers = {"x-api-key": self._api_key}
|
|
try:
|
|
async with self._session.get(
|
|
f"{self._url}/api/people",
|
|
headers=headers,
|
|
) as response:
|
|
if response.status == 200:
|
|
data = await response.json()
|
|
people_list = data.get("people", data) if isinstance(data, dict) else data
|
|
self._people_cache = {
|
|
p["id"]: p.get("name", "")
|
|
for p in people_list
|
|
if p.get("name")
|
|
}
|
|
except aiohttp.ClientError as err:
|
|
_LOGGER.warning("Failed to fetch people: %s", err)
|
|
|
|
return self._people_cache
|
|
|
|
async def _async_fetch_users(self) -> dict[str, str]:
|
|
"""Fetch all users from Immich and cache them."""
|
|
if self._session is None:
|
|
self._session = async_get_clientsession(self.hass)
|
|
|
|
headers = {"x-api-key": self._api_key}
|
|
try:
|
|
async with self._session.get(
|
|
f"{self._url}/api/users",
|
|
headers=headers,
|
|
) as response:
|
|
if response.status == 200:
|
|
data = await response.json()
|
|
self._users_cache = {
|
|
u["id"]: u.get("name", u.get("email", "Unknown"))
|
|
for u in data
|
|
if u.get("id")
|
|
}
|
|
except aiohttp.ClientError as err:
|
|
_LOGGER.warning("Failed to fetch users: %s", err)
|
|
|
|
return self._users_cache
|
|
|
|
async def _async_fetch_shared_links(self) -> dict[str, str]:
|
|
"""Fetch shared links from Immich and cache album_id -> share_key mapping."""
|
|
if self._session is None:
|
|
self._session = async_get_clientsession(self.hass)
|
|
|
|
headers = {"x-api-key": self._api_key}
|
|
try:
|
|
async with self._session.get(
|
|
f"{self._url}/api/shared-links",
|
|
headers=headers,
|
|
) as response:
|
|
if response.status == 200:
|
|
data = await response.json()
|
|
_LOGGER.debug("Fetched %d shared links from Immich", len(data))
|
|
self._shared_links_cache.clear()
|
|
for link in data:
|
|
# Only process album-type shared links
|
|
link_type = link.get("type", "")
|
|
album = link.get("album")
|
|
key = link.get("key")
|
|
_LOGGER.debug(
|
|
"Shared link: type=%s, key=%s, album_id=%s",
|
|
link_type,
|
|
key[:8] if key else None,
|
|
album.get("id") if album else None,
|
|
)
|
|
if album and key:
|
|
album_id = album.get("id")
|
|
if album_id:
|
|
self._shared_links_cache[album_id] = key
|
|
_LOGGER.debug(
|
|
"Cached %d album shared links", len(self._shared_links_cache)
|
|
)
|
|
else:
|
|
_LOGGER.warning(
|
|
"Failed to fetch shared links: HTTP %s", response.status
|
|
)
|
|
except aiohttp.ClientError as err:
|
|
_LOGGER.warning("Failed to fetch shared links: %s", err)
|
|
|
|
return self._shared_links_cache
|
|
|
|
def get_album_public_url(self, album_id: str) -> str | None:
|
|
"""Get the public URL for an album if it has a shared link."""
|
|
share_key = self._shared_links_cache.get(album_id)
|
|
if share_key:
|
|
return f"{self._url}/share/{share_key}"
|
|
return None
|
|
|
|
def _get_asset_public_url(self, album_id: str, asset_id: str) -> str | None:
|
|
"""Get the public URL for an asset if the album has a shared link."""
|
|
share_key = self._shared_links_cache.get(album_id)
|
|
if share_key:
|
|
return f"{self._url}/share/{share_key}/photos/{asset_id}"
|
|
return None
|
|
|
|
async def _async_update_data(self) -> dict[str, AlbumData]:
|
|
"""Fetch data from Immich API."""
|
|
if self._session is None:
|
|
self._session = async_get_clientsession(self.hass)
|
|
|
|
# Fetch users to resolve owner names
|
|
if not self._users_cache:
|
|
await self._async_fetch_users()
|
|
|
|
# Fetch shared links to resolve public URLs (refresh each time as links can change)
|
|
await self._async_fetch_shared_links()
|
|
|
|
headers = {"x-api-key": self._api_key}
|
|
albums_data: dict[str, AlbumData] = {}
|
|
|
|
for album_id in self._album_ids:
|
|
try:
|
|
async with self._session.get(
|
|
f"{self._url}/api/albums/{album_id}",
|
|
headers=headers,
|
|
) as response:
|
|
if response.status == 404:
|
|
_LOGGER.warning("Album %s not found, skipping", album_id)
|
|
continue
|
|
if response.status != 200:
|
|
raise UpdateFailed(
|
|
f"Error fetching album {album_id}: HTTP {response.status}"
|
|
)
|
|
|
|
data = await response.json()
|
|
album = AlbumData.from_api_response(data, self._users_cache)
|
|
|
|
# Detect changes and update flags
|
|
if album_id in self._previous_states:
|
|
change = self._detect_change(
|
|
self._previous_states[album_id], album
|
|
)
|
|
if change:
|
|
album.has_new_assets = change.added_count > 0
|
|
album.last_change_time = datetime.now()
|
|
self._fire_events(change, album)
|
|
else:
|
|
# First run, no changes
|
|
album.has_new_assets = False
|
|
|
|
# Preserve has_new_assets from previous state if still within window
|
|
if album_id in self._previous_states:
|
|
prev = self._previous_states[album_id]
|
|
if prev.has_new_assets and prev.last_change_time:
|
|
# Keep the flag if change was recent
|
|
album.last_change_time = prev.last_change_time
|
|
if not album.has_new_assets:
|
|
album.has_new_assets = prev.has_new_assets
|
|
|
|
albums_data[album_id] = album
|
|
|
|
except aiohttp.ClientError as err:
|
|
raise UpdateFailed(f"Error communicating with Immich: {err}") from err
|
|
|
|
# Update previous states
|
|
self._previous_states = albums_data.copy()
|
|
|
|
return albums_data
|
|
|
|
def _detect_change(
|
|
self, old_state: AlbumData, new_state: AlbumData
|
|
) -> AlbumChange | None:
|
|
"""Detect changes between two album states."""
|
|
added_ids = new_state.asset_ids - old_state.asset_ids
|
|
removed_ids = old_state.asset_ids - new_state.asset_ids
|
|
|
|
if not added_ids and not removed_ids:
|
|
return None
|
|
|
|
change_type = "changed"
|
|
if added_ids and not removed_ids:
|
|
change_type = "assets_added"
|
|
elif removed_ids and not added_ids:
|
|
change_type = "assets_removed"
|
|
|
|
# Get full asset info for added assets
|
|
added_assets = [
|
|
new_state.assets[aid] for aid in added_ids if aid in new_state.assets
|
|
]
|
|
|
|
return AlbumChange(
|
|
album_id=new_state.id,
|
|
album_name=new_state.name,
|
|
change_type=change_type,
|
|
added_count=len(added_ids),
|
|
removed_count=len(removed_ids),
|
|
added_assets=added_assets,
|
|
removed_asset_ids=list(removed_ids),
|
|
)
|
|
|
|
def _fire_events(self, change: AlbumChange, album: AlbumData) -> None:
|
|
"""Fire Home Assistant events for album changes."""
|
|
# Build detailed asset info for events
|
|
added_assets_detail = []
|
|
for asset in change.added_assets:
|
|
asset_detail = {
|
|
"id": asset.id,
|
|
ATTR_ASSET_TYPE: asset.type,
|
|
ATTR_ASSET_FILENAME: asset.filename,
|
|
ATTR_ASSET_CREATED: asset.created_at,
|
|
ATTR_ASSET_OWNER: asset.owner_name,
|
|
ATTR_ASSET_OWNER_ID: asset.owner_id,
|
|
ATTR_PEOPLE: asset.people,
|
|
}
|
|
# Add public URL if album has a shared link
|
|
asset_url = self._get_asset_public_url(change.album_id, asset.id)
|
|
if asset_url:
|
|
asset_detail[ATTR_ASSET_URL] = asset_url
|
|
added_assets_detail.append(asset_detail)
|
|
|
|
event_data = {
|
|
ATTR_ALBUM_ID: change.album_id,
|
|
ATTR_ALBUM_NAME: change.album_name,
|
|
ATTR_CHANGE_TYPE: change.change_type,
|
|
ATTR_ADDED_COUNT: change.added_count,
|
|
ATTR_REMOVED_COUNT: change.removed_count,
|
|
ATTR_ADDED_ASSETS: added_assets_detail,
|
|
ATTR_REMOVED_ASSETS: change.removed_asset_ids,
|
|
ATTR_PEOPLE: list(album.people),
|
|
}
|
|
|
|
# Add album public URL if it has a shared link
|
|
album_url = self.get_album_public_url(change.album_id)
|
|
if album_url:
|
|
event_data[ATTR_ALBUM_URL] = album_url
|
|
|
|
# Fire general change event
|
|
self.hass.bus.async_fire(EVENT_ALBUM_CHANGED, event_data)
|
|
|
|
_LOGGER.info(
|
|
"Album '%s' changed: +%d -%d assets",
|
|
change.album_name,
|
|
change.added_count,
|
|
change.removed_count,
|
|
)
|
|
|
|
# Fire specific events
|
|
if change.added_count > 0:
|
|
self.hass.bus.async_fire(EVENT_ASSETS_ADDED, event_data)
|
|
|
|
if change.removed_count > 0:
|
|
self.hass.bus.async_fire(EVENT_ASSETS_REMOVED, event_data)
|
|
|
|
def clear_new_assets_flag(self, album_id: str) -> None:
|
|
"""Clear the new assets flag for an album."""
|
|
if self.data and album_id in self.data:
|
|
self.data[album_id].has_new_assets = False
|
|
self.data[album_id].last_change_time = None
|