102 lines
3.1 KiB
Python
102 lines
3.1 KiB
Python
from __future__ import annotations
|
|
|
|
import argparse
|
|
import asyncio
|
|
import tempfile
|
|
import time
|
|
from pathlib import Path
|
|
|
|
from lrx_cli.authenticators import create_authenticators
|
|
from lrx_cli.cache import CacheEngine
|
|
from lrx_cli.config import AppConfig, load_config
|
|
from lrx_cli.fetchers import BaseFetcher, FetcherMethodType, create_fetchers
|
|
from lrx_cli.models import TrackMeta
|
|
|
|
SAMPLE_TRACK = TrackMeta(
|
|
title="One Last Kiss",
|
|
artist="Hikaru Utada",
|
|
album="One Last Kiss",
|
|
length=252026,
|
|
trackid="5RhWszHMSKzb7KiXk4Ae0M",
|
|
url="https://open.spotify.com/track/5RhWszHMSKzb7KiXk4Ae0M",
|
|
)
|
|
|
|
# Sources that reach out over the network end-to-end; "local" and "cache-search"
|
|
# have no I/O worth timing.
|
|
METHODS: list[FetcherMethodType] = [
|
|
"lrclib",
|
|
"lrclib-search",
|
|
"spotify",
|
|
"musixmatch-spotify",
|
|
"musixmatch",
|
|
"netease",
|
|
"qqmusic",
|
|
]
|
|
|
|
Row = tuple[str, float, str, str]
|
|
|
|
|
|
def _new_runtime(
|
|
config: AppConfig, db_path: Path
|
|
) -> dict[FetcherMethodType, BaseFetcher]:
|
|
cache = CacheEngine(str(db_path))
|
|
authenticators = create_authenticators(cache, config)
|
|
return create_fetchers(cache, authenticators, config)
|
|
|
|
|
|
async def _timed(name: str, fetcher: BaseFetcher) -> Row:
|
|
start = time.perf_counter()
|
|
try:
|
|
result = await fetcher.fetch(SAMPLE_TRACK, bypass_cache=True)
|
|
synced = result.synced.status.name if result.synced else "n/a"
|
|
unsynced = result.unsynced.status.name if result.unsynced else "n/a"
|
|
except Exception as exc: # noqa: BLE001
|
|
synced = unsynced = f"ERR: {exc}"
|
|
elapsed_ms = (time.perf_counter() - start) * 1000
|
|
return name, elapsed_ms, synced, unsynced
|
|
|
|
|
|
def _print_table(rows: list[Row]) -> None:
|
|
name_w = max(max(len(name) for name, _, _, _ in rows), len("source"))
|
|
synced_w = max(max(len(s) for _, _, s, _ in rows), len("synced"))
|
|
unsynced_w = max(max(len(u) for _, _, _, u in rows), len("unsynced"))
|
|
|
|
print(
|
|
f"{'source':<{name_w}} {'time(ms)':>10} "
|
|
f"{'synced':<{synced_w}} {'unsynced':<{unsynced_w}}"
|
|
)
|
|
print(
|
|
"-" * name_w + " " + "-" * 10 + " " + "-" * synced_w + " " + "-" * unsynced_w
|
|
)
|
|
for name, elapsed_ms, synced, unsynced in rows:
|
|
print(
|
|
f"{name:<{name_w}} {elapsed_ms:>10.1f} "
|
|
f"{synced:<{synced_w}} {unsynced:<{unsynced_w}}"
|
|
)
|
|
|
|
|
|
async def run_bench() -> list[Row]:
|
|
"""Time each fetcher's full `fetch()` pipeline (search/match + retrieval +
|
|
parsing), bypassing the on-disk cache but nothing else."""
|
|
with tempfile.TemporaryDirectory(prefix="lrx-bench-") as tmp:
|
|
fetchers = _new_runtime(load_config(), Path(tmp) / "cred.db")
|
|
return [await _timed(method, fetchers[method]) for method in METHODS]
|
|
|
|
|
|
def main() -> int:
|
|
parser = argparse.ArgumentParser(
|
|
description=(
|
|
"Time each source's full fetch() pipeline (search/match + retrieval + "
|
|
"parsing)."
|
|
)
|
|
)
|
|
parser.parse_args()
|
|
|
|
rows = asyncio.run(run_bench())
|
|
_print_table(rows)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|