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

1"""Paths for files stored outside the main download_dir tree.""" 

2 

3from __future__ import annotations 

4 

5import functools 

6import hashlib 

7import os 

8from collections.abc import Sequence 

9from dataclasses import dataclass 

10from pathlib import Path 

11from typing import Any, Optional 

12 

13SLSKD_LIBRARY_PREFIX = 'slskd/' 

14EXTERNAL_LIBRARY_PREFIX = 'ext/' 

15 

16 

17def path_relative_to_anchor(file_path: Path, anchor: Path) -> str: 

18 """Return a stable path relative to *anchor* (may use ``..`` segments).""" 

19 

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 ) 

28 

29 

30def resolve_stored_path(stored: str, anchor: Path) -> Path: 

31 """Resolve a stored relative path against *anchor*.""" 

32 

33 return (anchor / stored).resolve() 

34 

35 

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).""" 

39 

40 try: 

41 key = str(root.resolve()) 

42 except OSError: 

43 key = str(root) 

44 return hashlib.sha1(key.encode('utf-8')).hexdigest()[:12] 

45 

46 

47def extra_dir_lookup( 

48 extra_dirs: Optional[Sequence[Path]], 

49) -> dict[str, Path]: 

50 """``folder_id → root`` for the current extra-folder settings.""" 

51 

52 return {extra_dir_id(root): root for root in extra_dirs or ()} 

53 

54 

55@dataclass(frozen=True) 

56class ResolvedLibraryRoots: 

57 """Resolved download / slskd / extra roots, built once per listing.""" 

58 

59 download: Path 

60 slskd: Optional[Path] 

61 extras: tuple[tuple[Path, str], ...] 

62 

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)) 

88 

89 def stored_for(self, file_resolved: Path) -> str: 

90 """Library key for an already-resolved audio path.""" 

91 

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) 

109 

110 

111def extra_library_relative(stored: str) -> Optional[tuple[str, str]]: 

112 """``(folder_id, relative_path)`` for ``ext/<id>/...`` keys, else 

113 ``None``. 

114 """ 

115 

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 

124 

125 

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. 

133 

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 """ 

138 

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 

153 

154 

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). 

162 

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 """ 

169 

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) 

191 

192 

193def default_slskd_source_roots(download_dir: Path) -> list[Path]: 

194 """Common slskd mount locations when settings omit ``source_dir``.""" 

195 

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 

204 

205 

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 

217 

218 

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 

225 

226 

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.""" 

234 

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) 

249 

250 

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).""" 

258 

259 text = str(stored or '').strip().replace('\\', '/') 

260 if not text or text.startswith('/'): 

261 return None 

262 

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 ) 

280 

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