187 lines
4.9 KiB
Python
187 lines
4.9 KiB
Python
"""
|
|
Dependables for defining Routers.
|
|
"""
|
|
|
|
import logging
|
|
import re
|
|
from dataclasses import dataclass, field
|
|
from typing import Awaitable, Callable, Generic, ParamSpec, Self, TypeVar
|
|
|
|
from fastapi import Depends, HTTPException, params, status
|
|
from webdav3.exceptions import RemoteResourceNotFound
|
|
|
|
from ...core.caldav import CalDAV
|
|
from ...core.config import Config, get_config
|
|
from ...core.webdav import WebDAV
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
_RESPONSE_OK = {
|
|
status.HTTP_200_OK: {
|
|
"description": "Operation successful",
|
|
},
|
|
}
|
|
|
|
Params = ParamSpec("Params")
|
|
Return = TypeVar("Return")
|
|
|
|
type DependableFn[**Params, Return] = Callable[Params, Awaitable[Return]]
|
|
|
|
|
|
@dataclass(slots=True, frozen=True)
|
|
class Dependable(Generic[Params, Return]):
|
|
func: DependableFn[Params, Return]
|
|
responses: dict = field(default_factory=lambda: _RESPONSE_OK.copy())
|
|
|
|
|
|
@dataclass(slots=True, frozen=True)
|
|
class ListManager:
|
|
lister: Dependable[[], list[str]]
|
|
filter: Dependable[[str], list[str]]
|
|
getter: Dependable[[str], str]
|
|
|
|
@classmethod
|
|
def from_lister(cls, lister: Dependable[[], list[str]]) -> Self:
|
|
async def _filter_fn(
|
|
prefix: str,
|
|
names: list[str] = Depends(lister.func),
|
|
) -> list[str]:
|
|
if isinstance(names, params.Depends):
|
|
names = await lister.func()
|
|
|
|
_logger.debug("filter %s from %s", repr(prefix), repr(names))
|
|
|
|
return [item for item in names if item.lower().startswith(prefix.lower())]
|
|
|
|
async def _getter_fn(
|
|
prefix: str,
|
|
names: list[str] = Depends(_filter_fn),
|
|
) -> str:
|
|
if isinstance(names, params.Depends):
|
|
names = await _filter_fn(prefix)
|
|
|
|
_logger.debug("get %s from %s", repr(prefix), repr(names))
|
|
|
|
match names:
|
|
case [name]:
|
|
return name
|
|
|
|
case []:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
|
|
|
case _:
|
|
raise HTTPException(status_code=status.HTTP_409_CONFLICT)
|
|
|
|
return cls(
|
|
lister=lister,
|
|
filter=Dependable(_filter_fn),
|
|
getter=Dependable(
|
|
func=_getter_fn,
|
|
responses={
|
|
**_RESPONSE_OK,
|
|
status.HTTP_404_NOT_FOUND: {
|
|
"description": "Prefix not found",
|
|
"content": None,
|
|
},
|
|
status.HTTP_409_CONFLICT: {
|
|
"description": "Ambiguous prefix",
|
|
"content": None,
|
|
},
|
|
},
|
|
),
|
|
)
|
|
|
|
@classmethod
|
|
def from_lister_fn(cls, lister_fn: DependableFn[[], list[str]]) -> Self:
|
|
return cls.from_lister(Dependable(lister_fn))
|
|
|
|
|
|
def get_remote_path(
|
|
path_name: str,
|
|
) -> DependableFn[[], str]:
|
|
async def _get_remote_path() -> str:
|
|
cfg = await get_config()
|
|
return getattr(cfg, path_name)
|
|
|
|
return _get_remote_path
|
|
|
|
|
|
RP_FILE = get_remote_path("file_dir")
|
|
RP_IMAGE = get_remote_path("image_dir")
|
|
RP_TEXT = get_remote_path("text_dir")
|
|
|
|
|
|
def get_file_lister(
|
|
rp: DependableFn[[], str],
|
|
*,
|
|
re: re.Pattern[str],
|
|
) -> Dependable[[], list[str]]:
|
|
"""
|
|
List files in remote `path` matching the RegEx `re`
|
|
"""
|
|
|
|
async def _list_files(
|
|
remote_path: str = Depends(rp),
|
|
) -> list[str]:
|
|
if isinstance(remote_path, params.Depends):
|
|
remote_path = await rp()
|
|
|
|
_logger.debug("list %s", repr(remote_path))
|
|
|
|
try:
|
|
return await WebDAV.list_files(remote_path, regex=re)
|
|
|
|
except RemoteResourceNotFound:
|
|
_logger.error("WebDAV path %s lost!", repr(remote_path))
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
|
|
|
|
return Dependable(
|
|
func=_list_files,
|
|
responses={
|
|
**_RESPONSE_OK,
|
|
status.HTTP_404_NOT_FOUND: {
|
|
"description": "Remote path not found",
|
|
"content": None,
|
|
},
|
|
},
|
|
)
|
|
|
|
|
|
LM_FILE = ListManager.from_lister(
|
|
get_file_lister(rp=RP_FILE, re=re.compile(r"[^/]$", flags=re.IGNORECASE))
|
|
)
|
|
LM_IMAGE = ListManager.from_lister(
|
|
get_file_lister(
|
|
rp=RP_IMAGE, re=re.compile(r"\.(gif|jpe?g|tiff?|png|bmp)$", flags=re.IGNORECASE)
|
|
)
|
|
)
|
|
LM_TEXT = ListManager.from_lister(
|
|
get_file_lister(rp=RP_TEXT, re=re.compile(r"\.(txt|md)$", flags=re.IGNORECASE))
|
|
)
|
|
|
|
|
|
async def list_calendar_names() -> list[str]:
|
|
"""
|
|
List calendar names
|
|
"""
|
|
|
|
return await CalDAV.calendars
|
|
|
|
|
|
LM_CALENDARS = ListManager.from_lister_fn(list_calendar_names)
|
|
|
|
|
|
async def list_aggregate_names(
|
|
cfg: Config = Depends(get_config),
|
|
) -> list[str]:
|
|
"""
|
|
List aggregate calendar names
|
|
"""
|
|
|
|
if isinstance(cfg, params.Depends):
|
|
cfg = await get_config()
|
|
|
|
return list(cfg.calendar.aggregates.keys())
|
|
|
|
|
|
LM_AGGREGATES = ListManager.from_lister_fn(list_aggregate_names)
|