revisions

lyric_search_new/sources/cache.py

@@ -1,8 +1,10 @@
 #!/usr/bin/env python3.12
-# pylint: disable=wrong-import-position
+# pylint: disable=wrong-import-order, wrong-import-position bare-except, broad-exception-caught
 
 import os
+import logging
 import sys
+import traceback
 sys.path.insert(1,'..')
 sys.path.insert(1,'.')
 from typing import Optional
@@ -10,6 +12,9 @@ import aiosqlite as sqlite3
 from lyric_search_new import utils
 from lyric_search_new.constructors import LyricsResult
 
+logger = logging.getLogger()
+log_level = logging.getLevelName(logger.level)
+
 class Cache:
     """Cache Search Module"""
     def __init__(self):
@@ -44,33 +49,39 @@ class Cache:
         """
         artist = artist.strip().lower()
         song = song.strip().lower()
-        async with sqlite3.connect(self.cache_db, timeout=2) as db_conn:
-            await db_conn.enable_load_extension(True)
-            for ext in self.sqlite_exts:
-                await db_conn.load_extension(ext)
-            async with await db_conn.executescript(self.cache_pre_query) as _db_cursor:
-                search_query = 'SELECT id, artist, song, lyrics, src, confidence FROM lyrics\
-                    WHERE editdist3((artist || " " || song), (? || " " || ?))\
-                    <= 410 ORDER BY editdist3((artist || " " || song), ?) ASC LIMIT 10'
-                search_params = (artist.strip(), song.strip(),
-                                 f"{artist.strip()} {song.strip()}")
-                async with await _db_cursor.execute(search_query, search_params) as db_cursor:
-                    results = await db_cursor.fetchall()
-                    result_tracks = []
-                    for track in results:
-                        (_id, _artist, _song, _lyrics, _src, _confidence) = track
-                        result_tracks.append((_id, f"{_artist} - {_song}"))
-                    input_track = f"{artist} - {song}"
-                    matcher = utils.TrackMatcher()
-                    best_match = matcher.find_best_match(input_track=input_track,
-                                                         candidate_tracks=result_tracks)
-                    if not best_match:
-                        return None
-                    (candidate, confidence) = best_match
-                    return self.get_matched(sqlite_rows=results,
-                                            matched_candidate=candidate,
-                                            confidence=confidence)
-                                             
+        try:
+            async with sqlite3.connect(self.cache_db, timeout=2) as db_conn:
+                await db_conn.enable_load_extension(True)
+                for ext in self.sqlite_exts:
+                    await db_conn.load_extension(ext)
+                async with await db_conn.executescript(self.cache_pre_query) as _db_cursor:
+                    search_query = 'SELECT id, artist, song, lyrics, src, confidence FROM lyrics\
+                        WHERE editdist3((artist || " " || song), (? || " " || ?))\
+                        <= 410 ORDER BY editdist3((artist || " " || song), ?) ASC LIMIT 10'
+                    search_params = (artist.strip(), song.strip(),
+                                    f"{artist.strip()} {song.strip()}")
+                    async with await _db_cursor.execute(search_query, search_params) as db_cursor:
+                        results = await db_cursor.fetchall()
+                        result_tracks = []
+                        for track in results:
+                            (_id, _artist, _song, _lyrics, _src, _confidence) = track
+                            result_tracks.append((_id, f"{_artist} - {_song}"))
+                        input_track = f"{artist} - {song}"
+                        matcher = utils.TrackMatcher()
+                        best_match = matcher.find_best_match(input_track=input_track,
+                                                            candidate_tracks=result_tracks)
+                        if not best_match:
+                            return None
+                        (candidate, confidence) = best_match
+                        logging.info("Result found on %s", self.label)
+                        return self.get_matched(sqlite_rows=results,
+                                                matched_candidate=candidate,
+                                                confidence=confidence)
+        except:
+            if log_level == "DEBUG":
+                traceback.print_exc()
+            return
+