jozamudi
a8426b5922
- POST/GET /api/history: JSON file in data/history.json (50 entries kept, top 5 shown on home), upsert per (anime, episode) - watch position saved every ~10s of playback + on pause/unload - resume: opening an anime seeks to the saved position unless >=95% through (then starts fresh); position shown on home items - drops localStorage; server is the source of truth (verified: fresh watch -> new session resumes at saved pos -> home lists it)
129 lines
3.8 KiB
Python
129 lines
3.8 KiB
Python
"""app.py — ani-web: FastAPI over upstream.py + HLS proxy + static UI.
|
|
|
|
Browser playback: hls.anidb.app sends no CORS headers, so the player is
|
|
pointed at /stream/{token}; the proxy fetches upstream (with the same
|
|
Cloudflare workaround) and rewrites playlist URIs to go through itself.
|
|
"""
|
|
import base64
|
|
import json
|
|
import time
|
|
from pathlib import Path
|
|
from urllib.parse import urljoin
|
|
|
|
from fastapi import Body, FastAPI, HTTPException, Query
|
|
from fastapi.responses import Response
|
|
from fastapi.staticfiles import StaticFiles
|
|
|
|
import upstream
|
|
|
|
app = FastAPI(title="ani-web")
|
|
|
|
HIST_FILE = Path(__file__).parent / "data" / "history.json"
|
|
|
|
|
|
def _load_hist():
|
|
try:
|
|
return json.loads(HIST_FILE.read_text())
|
|
except (FileNotFoundError, json.JSONDecodeError):
|
|
return []
|
|
|
|
|
|
def _save_hist(entries):
|
|
HIST_FILE.parent.mkdir(exist_ok=True)
|
|
# ponytail: unguarded read-modify-write, fine for a single-user tool
|
|
HIST_FILE.write_text(json.dumps(entries, indent=1))
|
|
|
|
|
|
@app.get("/api/history")
|
|
def api_history():
|
|
return sorted(_load_hist(), key=lambda e: e.get("t", 0), reverse=True)[:5]
|
|
|
|
|
|
@app.post("/api/history")
|
|
def api_history_post(entry: dict = Body(...)):
|
|
if "ep_id" not in entry:
|
|
raise HTTPException(422, "ep_id required")
|
|
entry["t"] = time.time()
|
|
entries = _load_hist()
|
|
for i, e in enumerate(entries):
|
|
if e.get("slug_id") == entry.get("slug_id") and e.get("ep_id") == entry.get("ep_id"):
|
|
entries[i] = {**e, **entry}
|
|
break
|
|
else:
|
|
entries.append(entry)
|
|
_save_hist(sorted(entries, key=lambda e: e.get("t", 0), reverse=True)[:50])
|
|
return entry
|
|
|
|
|
|
def _b64(url: str) -> str:
|
|
return base64.urlsafe_b64encode(url.encode()).decode()
|
|
|
|
|
|
def _url(token: str) -> str:
|
|
return base64.urlsafe_b64decode(token.encode()).decode()
|
|
|
|
|
|
def _upstream(fn, *a, **kw):
|
|
try:
|
|
return fn(*a, **kw)
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
raise HTTPException(502, f"upstream error: {e}")
|
|
|
|
|
|
@app.middleware("http")
|
|
async def no_cache(request, call_next):
|
|
# ponytail: no-store on everything except /stream (segments should cache)
|
|
r = await call_next(request)
|
|
if not request.url.path.startswith("/stream"):
|
|
r.headers["Cache-Control"] = "no-store"
|
|
return r
|
|
|
|
|
|
@app.get("/api/search")
|
|
def api_search(q: str = Query(min_length=1)):
|
|
return _upstream(upstream.search, q)
|
|
|
|
|
|
@app.get("/api/anime/{slug_id}")
|
|
def api_anime(slug_id: str):
|
|
return _upstream(upstream.details, slug_id)
|
|
|
|
|
|
@app.get("/api/anime/{anime_id}/episodes")
|
|
def api_episodes(anime_id: int):
|
|
return _upstream(upstream.episodes, anime_id)
|
|
|
|
|
|
@app.get("/api/episode/{ep_id}/stream")
|
|
def api_stream(ep_id: int, lang: str = "eng"):
|
|
master = _upstream(upstream.master_m3u8, ep_id, lang)
|
|
if not master:
|
|
raise HTTPException(404, f"no {lang} stream for episode {ep_id}")
|
|
return {"token": _b64(master),
|
|
"qualities": _upstream(upstream.master_variants, master)}
|
|
|
|
|
|
def _rewrite_m3u8(text: str, base: str) -> str:
|
|
# ponytail: rewrites plain URIs only; URI-list attributes in
|
|
# #EXT-X-* tags (e.g. SUBTITLES) are ignored — fine for video-only playlists
|
|
return "\n".join(
|
|
line if line.startswith("#") or not line
|
|
else "/stream/" + _b64(urljoin(base, line))
|
|
for line in text.splitlines()) + "\n"
|
|
|
|
|
|
@app.get("/stream/{token}")
|
|
def stream(token: str):
|
|
# ponytail: buffers whole response in memory; .ts segments are small
|
|
url = _url(token)
|
|
r = _upstream(upstream._get, url)
|
|
body = r.content
|
|
if url.endswith(".m3u8") or "mpegurl" in r.headers.get("content-type", ""):
|
|
body = _rewrite_m3u8(body.decode(), url).encode()
|
|
return Response(body, media_type=r.headers.get("content-type", "application/octet-stream"))
|
|
|
|
|
|
app.mount("/", StaticFiles(directory="static", html=True), name="static")
|