Merge pull request #10 from jonaskahn/dev

Dev

Author: jonaskahn

engine/engine/processors/audio_processor.py

@@ -19,7 +19,7 @@ class __AudioChainProcessor:
     def __init__(self):
         self.filters: List[Callable[[str], str]] = []
 
-    def add_filter(self, func: Callable[[str], str]) -> '__AudioChainProcessor':
+    def add_filter(self, func: Callable[[str], str]) -> "__AudioChainProcessor":
         self.filters.append(func)
         return self
 
@@ -43,10 +43,8 @@ def mp4_to_wav(audio_input_path: str) -> str:
 
 
 def __sound_converter(
-        audio_input_path: str,
-        input_format: str,
-        output_format: str,
-        codec: str = None) -> str:
+    audio_input_path: str, input_format: str, output_format: str, codec: str = None
+) -> str:
     audio_output_file = os.path.join(TEMP_AUDIO_DIR, f"{uuid4()}.{output_format}")
     sound = AudioSegment.from_file(audio_input_path, format=input_format)
     sound.export(audio_output_file, format=output_format, codec=codec)
@@ -85,7 +83,12 @@ def denoise(audio_path: str) -> str:
 
 def process_audio(audio_path: str) -> str:
     if env.AUDIO_ENHANCE_ENABLED in ["yes", "on", "enabled"]:
-        return __AudioChainProcessor().add_filter(mp4_to_wav).add_filter(denoise).add_filter(remove_music).filter(
-            audio_path)
+        return (
+            __AudioChainProcessor()
+            .add_filter(mp4_to_wav)
+            .add_filter(denoise)
+            .add_filter(remove_music)
+            .filter(audio_path)
+        )
     else:
         return __AudioChainProcessor().add_filter(mp4_to_wav).filter(audio_path)

engine/engine/server.py

@@ -32,14 +32,14 @@
     logger.debug('use "spawn" for multi-process')
 
 
-@app.listener('before_server_start')
+@app.listener("before_server_start")
 async def connect_db(app, loop):
     logger.debug("open sqlite Connection")
     sqlite_client.connect()
     sqlite_client.create_tables([Video, VideoChapter, Chat])
 
 
-@app.listener('after_server_stop')
+@app.listener("after_server_stop")
 async def close_db(app, loop):
     if not sqlite_client.is_closed():
         logger.debug("close sqlite")
@@ -49,13 +49,7 @@ async def close_db(app, loop):
 @app.exception(Exception)
 async def handle_exception(request: Request, exception: Exception):
     logger.error(exception, exc_info=True)
-    return json(
-        {
-            "status_code": 500,
-            "message": str(exception)
-        },
-        status=500
-    )
+    return json({"status_code": 500, "message": str(exception)}, status=500)
 
 
 @app.exception(LogicError)
@@ -66,7 +60,7 @@ async def handle_exception(request: Request, exception: LogicError):
             "status_code": 400,
             "message": str(exception),
         },
-        status=500
+        status=500,
     )
 
 
@@ -77,38 +71,40 @@ async def health(request: Request):
 
 @app.post("/api/youtube/prefetch")
 async def fetch_youtube_video_info(request: Request):
-    url = request.json['url']
+    url = request.json["url"]
     youtube_service = YoutubeService(url)
     data = youtube_service.fetch_basic_info()
-    return json({
-        "status_code": 200,
-        "message": "Successfully fetch video info",
-        "payload": data
-    })
+    return json(
+        {
+            "status_code": 200,
+            "message": "Successfully fetch video info",
+            "payload": data,
+        }
+    )
 
 
 @app.post("/api/youtube/process")
 async def process_youtube_video(request: Request):
-    url = request.json['url']
-    provider = request.json['provider']
+    url = request.json["url"]
+    provider = request.json["provider"]
     youtube_service = YoutubeService(url)
     data = await asyncio.create_task(youtube_service.fetch_video_data(provider))
-    return json({
-        "status_code": 200,
-        "message": "Successfully fetch video data, analyze video in processing.",
-        "payload": data
-    })
+    return json(
+        {
+            "status_code": 200,
+            "message": "Successfully fetch video data, analyze video in processing.",
+            "payload": data,
+        }
+    )
 
 
 @app.post("/api/video/analysis")
 async def analysis_youtube_video(request: Request):
-    video_id: int = int(request.json['video_id'])
+    video_id: int = int(request.json["video_id"])
     data = await asyncio.create_task(VideoService.analysis_video(video_id))
-    return json({
-        "status_code": 200,
-        "message": "Analyze video in processing.",
-        "payload": data
-    })
+    return json(
+        {"status_code": 200, "message": "Analyze video in processing.", "payload": data}
+    )
 
 
 @app.options("/api/video/detail/<video_id>")
@@ -119,72 +115,66 @@ async def opts_detail(request: Request, video_id: int):
 @app.get("/api/video/detail/<video_id>")
 async def get_video_detail(request: Request, video_id: int):
     data = VideoService.get_video_detail(video_id)
-    return json({
-        "status_code": 200,
-        "message": "Successfully get video detail",
-        "payload": data
-    })
+    return json(
+        {
+            "status_code": 200,
+            "message": "Successfully get video detail",
+            "payload": data,
+        }
+    )
 
 
 @app.post("/api/video/summary")
 async def summary(request: Request):
-    vid = request.json['video_id']
-    lang_code = request.json['lang_code']
-    provider = request.json['provider']
+    vid = request.json["video_id"]
+    lang_code = request.json["lang_code"]
+    provider = request.json["provider"]
     model = request.json.get("model", None)
-    data = await asyncio.create_task(VideoService.summary_video(vid, lang_code, provider, model))
+    data = await asyncio.create_task(
+        VideoService.summary_video(vid, lang_code, provider, model)
+    )
     asyncio.create_task(VideoService.analysis_summary_video(vid, model, provider))
-    return json({
-        "status_code": 200,
-        "message": "Successfully summary video",
-        "payload": data
-    })
+    return json(
+        {"status_code": 200, "message": "Successfully summary video", "payload": data}
+    )
 
 
 @app.delete("/api/video/<video_id>")
 async def delete_video(request: Request, video_id: int):
     VideoService.delete(video_id)
-    return json({
-        "status_code": 200,
-        "message": f"Successfully delete video {video_id}"
-    })
+    return json(
+        {"status_code": 200, "message": f"Successfully delete video {video_id}"}
+    )
 
 
 @app.get("/api/videos/<page>")
 async def list_videos(request: Request, page: int):
     total, data = VideoService.get_videos_with_paging(page)
-    return json({
-        "status_code": 200,
-        "message": "Successfully",
-        "payload": {
-            "total": total,
-            "videos": data
+    return json(
+        {
+            "status_code": 200,
+            "message": "Successfully",
+            "payload": {"total": total, "videos": data},
         }
-    })
+    )
 
 
 @app.post("/api/chat")
 async def chat(request: Request):
-    vid = request.json['video_id']
-    question = request.json['question']
-    provider = request.json['provider']
+    vid = request.json["video_id"]
+    question = request.json["question"]
+    provider = request.json["provider"]
     model = request.json.get("model", None)
     data = await asyncio.create_task(ChatService.ask(question, vid, provider, model))
-    return json({
-        "status_code": 200,
-        "message": "Successfully",
-        "payload": data
-    })
+    return json({"status_code": 200, "message": "Successfully", "payload": data})
 
 
 @app.get("/api/chat/history/<video_id>")
 async def chat_history(request: Request, video_id: int):
     chat_histories = ChatService.get_chat_histories(video_id=video_id)
-    return json({
-        "status_code": 200,
-        "message": "Successfully",
-        "payload": chat_histories
-    })
+    return json(
+        {"status_code": 200, "message": "Successfully", "payload": chat_histories}
+    )
 
 
 @app.delete("/api/chat/clear/<video_id>")
@@ -193,7 +183,14 @@ async def clear_chat(request: Request, video_id: int):
     return response.HTTPResponse(status=200)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     setup_log()
     app_debug_mode = True if env.DEBUG_MODE in ["on", "yes", "enabled"] else False
-    app.run(host="0.0.0.0", port=8000, access_log=True, dev=app_debug_mode, debug=app_debug_mode, workers=10)
+    app.run(
+        host="0.0.0.0",
+        port=8000,
+        access_log=True,
+        dev=app_debug_mode,
+        debug=app_debug_mode,
+        workers=10,
+    )