Coverage for downtify/library_paths.py: 88%
189 statements
« prev ^ index » next coverage.py v7.17.4, created at 2026-11-21 22:18 +0000
« prev ^ index » next coverage.py v7.17.4, created at 2026-11-21 22:18 +0000
1"""Paths for files stored outside the main download_dir tree."""
3from __future__ import annotations
5import functools
6import hashlib
7import os
8from collections.abc import Sequence
9from dataclasses import dataclass
10from pathlib import Path
11from typing import Any, Optional
13SLSKD_LIBRARY_PREFIX = 'slskd/'
14EXTERNAL_LIBRARY_PREFIX = 'ext/'
17def path_relative_to_anchor(file_path: Path, anchor: Path) -> str:
18 """Return a stable path relative to *anchor* (may use ``..`` segments)."""
20 file_resolved = file_path.resolve()
21 anchor_resolved = anchor.resolve()
22 try:
23 return file_resolved.relative_to(anchor_resolved).as_posix()
24 except ValueError:
25 return os.path.relpath(file_resolved, anchor_resolved).replace(
26 '\\', '/'
27 )
30def resolve_stored_path(stored: str, anchor: Path) -> Path:
31 """Resolve a stored relative path against *anchor*."""
33 return (anchor / stored).resolve()
36@functools.lru_cache(maxsize=256)
37def extra_dir_id(root: Path) -> str:
38 """Stable id for an extra library folder (path hash, not the index)."""
40 try:
41 key = str(root.resolve())
42 except OSError:
43 key = str(root)
44 return hashlib.sha1(key.encode('utf-8')).hexdigest()[:12]
47def extra_dir_lookup(
48 extra_dirs: Optional[Sequence[Path]],
49) -> dict[str, Path]:
50 """``folder_id → root`` for the current extra-folder settings."""
52 return {extra_dir_id(root): root for root in extra_dirs or ()}
55@dataclass(frozen=True)
56class ResolvedLibraryRoots:
57 """Resolved download / slskd / extra roots, built once per listing."""
59 download: Path
60 slskd: Optional[Path]
61 extras: tuple[tuple[Path, str], ...]
63 @classmethod
64 def from_dirs(
65 cls,
66 download_dir: Path,
67 slskd_dir: Optional[Path] = None,
68 extra_dirs: Optional[Sequence[Path]] = None,
69 ) -> ResolvedLibraryRoots:
70 try:
71 download = download_dir.resolve()
72 except OSError:
73 download = Path(download_dir)
74 slskd: Optional[Path] = None
75 if slskd_dir is not None:
76 try:
77 slskd = slskd_dir.resolve()
78 except OSError:
79 slskd = Path(slskd_dir)
80 extras: list[tuple[Path, str]] = []
81 for root in extra_dirs or ():
82 try:
83 resolved = root.resolve()
84 except OSError:
85 resolved = Path(root)
86 extras.append((resolved, extra_dir_id(root)))
87 return cls(download=download, slskd=slskd, extras=tuple(extras))
89 def stored_for(self, file_resolved: Path) -> str:
90 """Library key for an already-resolved audio path."""
92 try:
93 return file_resolved.relative_to(self.download).as_posix()
94 except ValueError:
95 pass
96 if self.slskd is not None:
97 try:
98 rel = file_resolved.relative_to(self.slskd).as_posix()
99 return f'{SLSKD_LIBRARY_PREFIX}{rel}'
100 except ValueError:
101 pass
102 for extra_root, folder_id in self.extras:
103 try:
104 rel = file_resolved.relative_to(extra_root).as_posix()
105 except ValueError:
106 continue
107 return f'{EXTERNAL_LIBRARY_PREFIX}{folder_id}/{rel}'
108 return path_relative_to_anchor(file_resolved, self.download)
111def extra_library_relative(stored: str) -> Optional[tuple[str, str]]:
112 """``(folder_id, relative_path)`` for ``ext/<id>/...`` keys, else
113 ``None``.
114 """
116 text = str(stored or '').strip().replace('\\', '/')
117 if not text.startswith(EXTERNAL_LIBRARY_PREFIX):
118 return None
119 rest = text[len(EXTERNAL_LIBRARY_PREFIX) :].lstrip('/')
120 folder_id, sep, rel = rest.partition('/')
121 if not folder_id or not sep or not rel:
122 return None
123 return folder_id, rel
126def library_file_root(
127 stored: str,
128 download_dir: Path,
129 slskd_dir: Optional[Path] = None,
130 extra_dirs: Optional[Sequence[Path]] = None,
131) -> tuple[Path, str]:
132 """``(tree root, path relative to it)`` for a library stored key.
134 Extra folders (``ext/<id>/...``) and slskd (``slskd/...``) live
135 outside *download_dir*; deletes and leftover pruning must stop at
136 that tree, not treat the key as a file under ``/downloads``.
137 """
139 text = str(stored or '').replace('\\', '/')
140 parsed = extra_library_relative(text)
141 if parsed is not None:
142 folder_id, rel = parsed
143 root = extra_dir_lookup(extra_dirs).get(folder_id)
144 if root is not None:
145 try:
146 return root.resolve(), rel
147 except OSError:
148 return root, rel
149 return download_dir, text
150 if slskd_dir is not None and text.startswith(SLSKD_LIBRARY_PREFIX):
151 return slskd_dir.resolve(), text[len(SLSKD_LIBRARY_PREFIX) :]
152 return download_dir, text
155def library_stored_path(
156 file_path: Path,
157 download_dir: Path,
158 slskd_dir: Optional[Path] = None,
159 extra_dirs: Optional[Sequence[Path]] = None,
160) -> str:
161 """Stable library key for API/DB/URLs (no ``..`` segments).
163 Files under *download_dir* stay relative to it. Files under *slskd_dir*
164 use the virtual prefix ``slskd/`` so clients request
165 ``/media/slskd/...`` instead of ``/media/../slskd/...`` (browsers
166 normalize the latter away from the media route). Extra library folders
167 (see ``downtify.external_library``) use ``ext/<id>/...``.
168 """
170 file_resolved = file_path.resolve()
171 anchor_resolved = download_dir.resolve()
172 try:
173 return file_resolved.relative_to(anchor_resolved).as_posix()
174 except ValueError:
175 pass
176 if slskd_dir is not None:
177 slskd_resolved = slskd_dir.resolve()
178 try:
179 rel = file_resolved.relative_to(slskd_resolved).as_posix()
180 return f'{SLSKD_LIBRARY_PREFIX}{rel}'
181 except ValueError:
182 pass
183 for root in extra_dirs or ():
184 try:
185 extra_resolved = root.resolve()
186 rel = file_resolved.relative_to(extra_resolved).as_posix()
187 except (OSError, ValueError):
188 continue
189 return f'{EXTERNAL_LIBRARY_PREFIX}{extra_dir_id(root)}/{rel}'
190 return path_relative_to_anchor(file_path, download_dir)
193def default_slskd_source_roots(download_dir: Path) -> list[Path]:
194 """Common slskd mount locations when settings omit ``source_dir``."""
196 roots: list[Path] = []
197 env = os.getenv('DOWNTIFY_SLSKD_SOURCE_DIR', '').strip()
198 if env:
199 roots.append(Path(env))
200 for candidate in (Path('/slskd'), download_dir / 'slskd'):
201 if candidate not in roots:
202 roots.append(candidate)
203 return roots
206def slskd_dir_from_downloader(downloader: Any) -> Optional[Path]:
207 settings = getattr(downloader, 'slskd_settings', {}) or {}
208 raw = str(settings.get('source_dir') or '').strip()
209 if raw:
210 return Path(raw)
211 if bool(settings.get('enabled')):
212 download_dir = Path(str(settings.get('download_dir') or '/downloads'))
213 for candidate in default_slskd_source_roots(download_dir):
214 if candidate.is_dir():
215 return candidate
216 return None
219def _slskd_relative(stored: str) -> Optional[str]:
220 text = str(stored or '').strip().replace('\\', '/')
221 if not text.startswith(SLSKD_LIBRARY_PREFIX):
222 return None
223 rel = text[len(SLSKD_LIBRARY_PREFIX) :].lstrip('/')
224 return rel or None
227def resolve_library_stored_path(
228 stored: str,
229 download_dir: Path,
230 slskd_dir: Optional[Path] = None,
231 extra_dirs: Optional[Sequence[Path]] = None,
232) -> Path:
233 """Resolve a library stored path to an absolute filesystem path."""
235 text = str(stored or '').strip().replace('\\', '/')
236 parsed = extra_library_relative(text)
237 if parsed is not None:
238 folder_id, rel = parsed
239 root = extra_dir_lookup(extra_dirs).get(folder_id)
240 if root is not None:
241 return (root / rel).resolve()
242 return (download_dir / text).resolve()
243 rel = _slskd_relative(text)
244 if rel is not None:
245 if slskd_dir is not None:
246 return (slskd_dir / rel).resolve()
247 return (download_dir / 'slskd' / rel).resolve()
248 return resolve_stored_path(text, download_dir)
251def locate_library_file(
252 stored: str,
253 download_dir: Path,
254 slskd_dir: Optional[Path] = None,
255 extra_dirs: Optional[Sequence[Path]] = None,
256) -> Optional[Path]:
257 """Resolve *stored* to an on-disk file (extra, slskd, legacy roots)."""
259 text = str(stored or '').strip().replace('\\', '/')
260 if not text or text.startswith('/'):
261 return None
263 candidates: list[Path] = []
264 parsed = extra_library_relative(text)
265 if parsed is not None:
266 folder_id, rel = parsed
267 root = extra_dir_lookup(extra_dirs).get(folder_id)
268 if root is not None:
269 candidates.append((root / rel).resolve())
270 rel = _slskd_relative(text)
271 if rel is not None:
272 if slskd_dir is not None:
273 candidates.append((slskd_dir / rel).resolve())
274 for root in default_slskd_source_roots(download_dir):
275 candidates.append((root / rel).resolve())
276 candidates.append((download_dir / 'slskd' / rel).resolve())
277 candidates.append(
278 resolve_library_stored_path(text, download_dir, slskd_dir, extra_dirs)
279 )
281 seen: set[str] = set()
282 for path in candidates:
283 key = str(path)
284 if key in seen:
285 continue
286 seen.add(key)
287 try:
288 if path.is_file():
289 return path
290 except OSError:
291 continue
292 return None