cleanup

lyric_search/sources/redis_cache.py

@@ -1,7 +1,4 @@
 #!/usr/bin/env python3.12
-# pylint: disable=bare-except, broad-exception-caught, wrong-import-order
-# pylint: disable=wrong-import-position
-
 
 import logging
 import traceback
@@ -9,7 +6,9 @@ import json
 import time
 import sys
 import regex
+from regex import Pattern
 import asyncio
+from typing import Union, Optional
 sys.path.insert(1,'..')
 from lyric_search import notifier
 from lyric_search.constructors import LyricsResult
@@ -20,10 +19,6 @@ from redis.commands.search.field import TextField, TagField
 from redis.commands.json.path import Path
 from . import private
 
-
-
-
-
 logger = logging.getLogger()
 log_level = logging.getLevelName(logger.level)
 
@@ -41,14 +36,15 @@ class RedisCache:
         self.redis_client = redis.Redis(password=private.REDIS_PW)
         self.notifier = notifier.DiscordNotifier()
         self.notify_warnings = True
-        self.regexes = [
+        self.regexes: list[Pattern] = [
             regex.compile(r'\-'),
             regex.compile(r'[^a-zA-Z0-9\s]'),
         ]
         try:
             asyncio.get_event_loop().create_task(self.create_index())
-        except:
-            pass
+        except Exception as e:
+            logging.debug("Failed to create redis create_index task: %s",
+                          str(e))
     
     async def create_index(self) -> None:
         """Create Index"""
@@ -64,10 +60,11 @@ class RedisCache:
             if str(result) != "OK":
                 raise RedisException(f"Redis: Failed to create index: {result}")
         except Exception as e:
-            pass
-            # await self.notifier.send(f"ERROR @ {__file__.rsplit("/", maxsplit=1)[-1]}", f"Failed to create idx: {str(e)}")
+            logging.debug("Failed to create redis index: %s",
+                          str(e))
             
-    def sanitize_input(self, artist: str, song: str, fuzzy: bool = False) -> tuple[str, str]:
+    def sanitize_input(self, artist: str, song: str,
+                       fuzzy: Optional[bool] = False) -> tuple[str, str]:
         """
         Sanitize artist/song input (convert to redis matchable fuzzy query)
         Args:
@@ -121,7 +118,9 @@ class RedisCache:
             traceback.print_exc()
         
     
-    async def search(self, **kwargs) -> list[tuple]:
+    async def search(self, artist: Optional[str] = None,
+                     song: Optional[str] = None,
+                     lyrics: Optional[str] = None) -> list[tuple]:
         """
         Search Redis Cache
         Args:
@@ -133,9 +132,6 @@ class RedisCache:
         """
 
         try:
-            artist = kwargs.get('artist', '')
-            song = kwargs.get('song', '')
-            lyrics = kwargs.get('lyrics')
             fuzzy_artist = None
             fuzzy_song = None            
             is_random_search = artist == "!" and song == "!"
@@ -148,10 +144,10 @@ class RedisCache:
                 logging.debug("Redis: Searching normally first")
                 (artist, song) = self.sanitize_input(artist, song)
                 logging.debug("Seeking: %s - %s", artist, song)
-                search_res = await self.redis_client.ft().search(Query(
+                search_res: Union[dict, list] = await self.redis_client.ft().search(Query(
                     f"@artist:{artist} @song:{song}"
                     ))
-                search_res_out = [(result['id'].split(":",
+                search_res_out: list[tuple] = [(result['id'].split(":",
                                                       maxsplit=1)[1], dict(json.loads(result['json'])))
                                   for result in search_res.docs]
                 if not search_res_out:
@@ -167,8 +163,8 @@ class RedisCache:
                                       for result in search_res.docs]                    
                                         
             else:
-                random_redis_key = await self.redis_client.randomkey()
-                out_id = str(random_redis_key).split(":",
+                random_redis_key: str = await self.redis_client.randomkey()
+                out_id: str = str(random_redis_key).split(":",
                                                      maxsplit=1)[1][:-1]
                 search_res = await self.redis_client.json().get(random_redis_key)
                 search_res_out = [(out_id, search_res)]
@@ -179,7 +175,8 @@ class RedisCache:
         except Exception as e:
             traceback.print_exc()
             # await self.notifier.send(f"ERROR @ {__file__.rsplit("/", maxsplit=1)[-1]}", f"{str(e)}\nSearch was: {artist} - {song}; fuzzy: {fuzzy_artist} - {fuzzy_song}")
-    async def redis_store(self, sqlite_id: int, lyr_result: LyricsResult) -> None:
+    async def redis_store(self, sqlite_id: int,
+                          lyr_result: LyricsResult) -> None:
         """
         Store lyrics to redis cache
         Args:
@@ -191,7 +188,7 @@ class RedisCache:
         try:
             (search_artist, search_song) = self.sanitize_input(lyr_result.artist,
                                                                lyr_result.song)
-            redis_mapping = {
+            redis_mapping: dict = {
                     'id': sqlite_id,
                     'src': lyr_result.src,
                     'date_retrieved': time.time(),
@@ -206,8 +203,8 @@ class RedisCache:
                     'tags': '(none)',
                     'liked': 0,
                 }
-            newkey = f"lyrics:000{sqlite_id}"
-            jsonset = await self.redis_client.json().set(newkey, Path.root_path(),
+            newkey: str = f"lyrics:000{sqlite_id}"
+            jsonset: bool = await self.redis_client.json().set(newkey, Path.root_path(),
                                                         redis_mapping)            
             if not jsonset:
                 raise RedisException(f"Failed to store {lyr_result.artist} - {lyr_result.song} (SQLite id: {sqlite_id}) to redis:\n{jsonset}")