radio_util: open tracks SQLite DB in readonly mode; black: reformat files

endpoints/misc.py

@@ -2,20 +2,18 @@ import logging
 import time
 import os
 from typing import Optional, Annotated
-from fastapi import (
-    FastAPI, Request, UploadFile,
-    Response, HTTPException, Form
-)
+from fastapi import FastAPI, Request, UploadFile, Response, HTTPException, Form
 from fastapi.responses import JSONResponse
 import redis.asyncio as redis
 from lyric_search.sources import private, cache as LyricsCache, redis_cache
 
+
 class Misc(FastAPI):
     """
     Misc Endpoints
     """
-    def __init__(self, app: FastAPI, my_util,
-                 constants, radio) -> None:
+
+    def __init__(self, app: FastAPI, my_util, constants, radio) -> None:
         self.app: FastAPI = app
         self.util = my_util
         self.constants = constants
@@ -28,47 +26,55 @@ class Misc(FastAPI):
             "widget/redis": self.homepage_redis_widget,
             "widget/sqlite": self.homepage_sqlite_widget,
             "widget/lyrics": self.homepage_lyrics_widget,
-            "widget/radio": self.homepage_radio_widget,            
+            "widget/radio": self.homepage_radio_widget,
             "misc/get_activity_image": self.get_activity_image,
         }
-        
+
         for endpoint, handler in self.endpoints.items():
-            app.add_api_route(f"/{endpoint}", handler, methods=["GET"],
-                              include_in_schema=True)
-            
-        app.add_api_route("/misc/upload_activity_image", 
-                          self.upload_activity_image, methods=["POST"])
-    
-    async def upload_activity_image(self,
-                                    image: UploadFile,
-                                    key: Annotated[str, Form()], request: Request) -> Response:
-        if not key or not isinstance(key, str)\
-            or not self.util.check_key(path=request.url.path, req_type=2, key=key):
-                raise HTTPException(status_code=403, detail="Unauthorized")    
+            app.add_api_route(
+                f"/{endpoint}", handler, methods=["GET"], include_in_schema=True
+            )
+
+        app.add_api_route(
+            "/misc/upload_activity_image", self.upload_activity_image, methods=["POST"]
+        )
+
+    async def upload_activity_image(
+        self, image: UploadFile, key: Annotated[str, Form()], request: Request
+    ) -> Response:
+        if (
+            not key
+            or not isinstance(key, str)
+            or not self.util.check_key(path=request.url.path, req_type=2, key=key)
+        ):
+            raise HTTPException(status_code=403, detail="Unauthorized")
         if not image:
-            return JSONResponse(status_code=500, content={
-                'err': True,
-                'errorText': 'Invalid request',
-            })
+            return JSONResponse(
+                status_code=500,
+                content={
+                    "err": True,
+                    "errorText": "Invalid request",
+                },
+            )
         self.activity_image = await image.read()
-        return JSONResponse(content={
-            'success': True,
-        })
-        
+        return JSONResponse(
+            content={
+                "success": True,
+            }
+        )
+
     async def get_activity_image(self, request: Request) -> Response:
         if isinstance(self.activity_image, bytes):
-            return Response(content=self.activity_image,
-                            media_type="image/png")
-        
-        
+            return Response(content=self.activity_image, media_type="image/png")
+
         # Fallback
-        fallback_path = os.path.join("/var/www/codey.lol/public",
-                                     "images", "plex_placeholder.png")
-        
-        with open(fallback_path, 'rb') as f:
-            return Response(content=f.read(),
-                            media_type="image/png")
-        
+        fallback_path = os.path.join(
+            "/var/www/codey.lol/public", "images", "plex_placeholder.png"
+        )
+
+        with open(fallback_path, "rb") as f:
+            return Response(content=f.read(), media_type="image/png")
+
     async def get_radio_np(self) -> tuple[str, str, str]:
         """
         Get radio now playing
@@ -77,76 +83,94 @@ class Misc(FastAPI):
         Returns:
             str: Radio now playing in artist - song format
         """
-        
+
         np: dict = self.radio.radio_util.now_playing
-        artistsong: str = np.get('artistsong', 'N/A - N/A')
-        album: str = np.get('album', 'N/A')
-        genre: str = np.get('genre', 'N/A')
+        artistsong: str = np.get("artistsong", "N/A - N/A")
+        album: str = np.get("album", "N/A")
+        genre: str = np.get("genre", "N/A")
         return (artistsong, album, genre)
-        
-            
+
     async def homepage_redis_widget(self) -> JSONResponse:
         """
         Homepage Redis Widget Handler
         """
         # Measure response time w/ test lyric search
-        time_start: float = time.time() # Start time for response_time
-        test_lyrics_result = await self.redis_client.ft().search("@artist: test @song: test")
+        time_start: float = time.time()  # Start time for response_time
+        test_lyrics_result = await self.redis_client.ft().search(
+            "@artist: test @song: test"
+        )
         time_end: float = time.time()
         # End response time test
         total_keys = await self.redis_client.dbsize()
-        response_time: float = time_end - time_start   
-        (_, ci_keys) = await self.redis_client.scan(cursor=0, match="ci_session*", count=10000000)
+        response_time: float = time_end - time_start
+        (_, ci_keys) = await self.redis_client.scan(
+            cursor=0, match="ci_session*", count=10000000
+        )
         num_ci_keys = len(ci_keys)
         index_info = await self.redis_client.ft().info()
-        indexed_lyrics: int = index_info.get('num_docs')
-        return JSONResponse(content={
-            'responseTime': round(response_time, 7),
-            'storedKeys': total_keys,
-            'indexedLyrics': indexed_lyrics,
-            'sessions': num_ci_keys,
-        })
-        
+        indexed_lyrics: int = index_info.get("num_docs")
+        return JSONResponse(
+            content={
+                "responseTime": round(response_time, 7),
+                "storedKeys": total_keys,
+                "indexedLyrics": indexed_lyrics,
+                "sessions": num_ci_keys,
+            }
+        )
+
     async def homepage_sqlite_widget(self) -> JSONResponse:
         """
         Homepage SQLite Widget Handler
-        """        
+        """
         row_count: int = await self.lyr_cache.sqlite_rowcount()
         distinct_artists: int = await self.lyr_cache.sqlite_distinct("artist")
         lyrics_length: int = await self.lyr_cache.sqlite_lyrics_length()
-        return JSONResponse(content={
-            'storedRows': row_count,
-            'distinctArtists': distinct_artists,
-            'lyricsLength': lyrics_length,
-        })
-        
+        return JSONResponse(
+            content={
+                "storedRows": row_count,
+                "distinctArtists": distinct_artists,
+                "lyricsLength": lyrics_length,
+            }
+        )
+
     async def homepage_lyrics_widget(self) -> JSONResponse:
         """
         Homepage Lyrics Widget Handler
         """
         found_counts: Optional[dict] = await self.redis_cache.get_found_counts()
         if not isinstance(found_counts, dict):
-            logging.info("DEBUG: Type of found counts from redis: %s\nContents: %s",
-                          type(found_counts), found_counts)
-            return JSONResponse(status_code=500, content={
-                'err': True,
-                'errorText': 'General failure.',
-            })
+            logging.info(
+                "DEBUG: Type of found counts from redis: %s\nContents: %s",
+                type(found_counts),
+                found_counts,
+            )
+            return JSONResponse(
+                status_code=500,
+                content={
+                    "err": True,
+                    "errorText": "General failure.",
+                },
+            )
         return JSONResponse(content=found_counts)
-    
+
     async def homepage_radio_widget(self) -> JSONResponse:
         """
         Homepage Radio Widget Handler
         """
         radio_np: tuple = await self.get_radio_np()
         if not radio_np:
-            return JSONResponse(status_code=500, content={
-                'err': True,
-                'errorText': 'General failure.',
-            })
+            return JSONResponse(
+                status_code=500,
+                content={
+                    "err": True,
+                    "errorText": "General failure.",
+                },
+            )
         (artistsong, album, genre) = radio_np
-        return JSONResponse(content={
-            'now_playing': artistsong,
-            'album': album,
-            'genre': genre,
-        })
+        return JSONResponse(
+            content={
+                "now_playing": artistsong,
+                "album": album,
+                "genre": genre,
+            }
+        )