Upload 67 files

src/agents/agent_transcript/flow.py

@@ -19,6 +19,13 @@ class AgentTranscript:
     def __init__(self):
         self.builder = StateGraph(State)
 
+    @staticmethod
+    def check_existed_comment(state: State):
+        if not state["comment"]:
+            return "scientific_fact_finder"
+        else:
+            return "comment_insight_extractor"
+
     def node(self):
         self.builder.add_node("trim_history", trim_history)
         self.builder.add_node(
@@ -38,30 +45,37 @@ class AgentTranscript:
         self.builder.add_edge(
             "extract_transcript_and_comment", "script_structure_analyzer"
         )
-        self.builder.add_edge("script_structure_analyzer", "comment_insight_extractor")
+        self.builder.add_conditional_edges(
+            "script_structure_analyzer",
+            self.check_existed_comment,
+            {
+                "scientific_fact_finder": "scientific_fact_finder",
+                "comment_insight_extractor": "comment_insight_extractor",
+            },
+        )
         self.builder.add_edge("comment_insight_extractor", "scientific_fact_finder")
         self.builder.add_edge("scientific_fact_finder", "script_re_outline")
         self.builder.add_edge("script_re_outline", "script_writer_init")
-        
+
         # Conditional routing for script writing
         self.builder.add_conditional_edges(
             "script_writer_init",
             should_continue_writing,
             {
                 "script_writer_single": "script_writer_single",
-                "script_writer_end": "script_writer_end"
-            }
+                "script_writer_end": "script_writer_end",
+            },
         )
-        
+
         self.builder.add_conditional_edges(
             "script_writer_single",
             should_continue_writing,
             {
                 "script_writer_single": "script_writer_single",
-                "script_writer_end": "script_writer_end"
-            }
+                "script_writer_end": "script_writer_end",
+            },
         )
-        
+
         self.builder.add_edge("script_writer_end", END)
 
     def __call__(self) -> CompiledStateGraph:

src/apis/routers/gen_script.py

@@ -28,121 +28,114 @@ async def message_generator(
     input_graph: dict,
     config: RunnableConfig,
 ):
-    try:
-        last_output_state = None
-
-        try:
-            async for event in script_writer_agent.astream(
-                input=input_graph, stream_mode=["messages", "values"], config=config
+    # try:
+    last_output_state = None
+
+    # try:
+    async for event in script_writer_agent.astream(
+        input=input_graph, stream_mode=["messages", "values"], config=config
+    ):
+        # try:
+        event_type, event_message = event
+        logger.info(f"Event type: {event_type}")
+
+        if event_type == "messages":
+            message, metadata = event_message
+            if isinstance(message, AIMessageChunk):
+                # Stream AI message chunks
+                node = metadata.get("node")
+                chunk_data = {
+                    "type": "message_chunk",
+                    "content": message.content,
+                    "metadata": metadata,
+                    "node_step": node,
+                }
+                logger.info(f"Chunk data: {chunk_data}")
+                yield f"data: {json.dumps(chunk_data)}\n\n"
+
+        elif event_type == "values":
+            # Stream state updates
+            state_data = {"type": "state_update", "state": event_message}
+            last_output_state = event_message
+
+            # Handle specific data extractions
+            if "transcript" in event_message and event_message["transcript"]:
+                transcript_data = {
+                    "type": "transcript_extracted",
+                    "transcript": (
+                        event_message["transcript"][:500] + "..."
+                        if len(event_message["transcript"]) > 500
+                        else event_message["transcript"]
+                    ),
+                    "full_length": len(event_message["transcript"]),
+                }
+                yield f"data: {json.dumps(transcript_data)}\n\n"
+
+            if "comment" in event_message and event_message["comment"]:
+                comment_data = {
+                    "type": "comment_extracted",
+                    "comment": (
+                        event_message["comment"][:500] + "..."
+                        if len(event_message["comment"]) > 500
+                        else event_message["comment"]
+                    ),
+                    "full_length": len(event_message["comment"]),
+                }
+                yield f"data: {json.dumps(comment_data)}\n\n"
+
+            if "script_count" in event_message:
+                script_count_data = {
+                    "type": "script_count_calculated",
+                    "script_count": event_message["script_count"],
+                    "target_word_count": event_message.get("target_word_count", 8000),
+                }
+                yield f"data: {json.dumps(script_count_data)}\n\n"
+
+            # Handle individual script updates
+            if (
+                "script_writer_response" in event_message
+                and "current_script_index" in event_message
             ):
-                try:
-                    event_type, event_message = event
-                    logger.info(f"Event type: {event_type}")
-
-                    if event_type == "messages":
-                        message, metadata = event_message
-                        if isinstance(message, AIMessageChunk):
-                            # Stream AI message chunks
-                            node = metadata.get("node")
-                            chunk_data = {
-                                "type": "message_chunk",
-                                "content": message.content,
-                                "metadata": metadata,
-                                "node_step": node,
-                            }
-                            logger.info(f"Chunk data: {chunk_data}")
-                            yield f"data: {json.dumps(chunk_data)}\n\n"
-
-                    elif event_type == "values":
-                        # Stream state updates
-                        state_data = {"type": "state_update", "state": event_message}
-                        last_output_state = event_message
-
-                        # Handle specific data extractions
-                        if (
-                            "transcript" in event_message
-                            and event_message["transcript"]
-                        ):
-                            transcript_data = {
-                                "type": "transcript_extracted",
-                                "transcript": (
-                                    event_message["transcript"][:500] + "..."
-                                    if len(event_message["transcript"]) > 500
-                                    else event_message["transcript"]
-                                ),
-                                "full_length": len(event_message["transcript"]),
-                            }
-                            yield f"data: {json.dumps(transcript_data)}\n\n"
-
-                        if "comment" in event_message and event_message["comment"]:
-                            comment_data = {
-                                "type": "comment_extracted",
-                                "comment": (
-                                    event_message["comment"][:500] + "..."
-                                    if len(event_message["comment"]) > 500
-                                    else event_message["comment"]
-                                ),
-                                "full_length": len(event_message["comment"]),
-                            }
-                            yield f"data: {json.dumps(comment_data)}\n\n"
-
-                        if "script_count" in event_message:
-                            script_count_data = {
-                                "type": "script_count_calculated",
-                                "script_count": event_message["script_count"],
-                                "target_word_count": event_message.get(
-                                    "target_word_count", 8000
-                                ),
-                            }
-                            yield f"data: {json.dumps(script_count_data)}\n\n"
-
-                        # Handle individual script updates
-                        if (
-                            "script_writer_response" in event_message
-                            and "current_script_index" in event_message
-                        ):
-                            current_scripts = event_message["script_writer_response"]
-                            current_index = event_message["current_script_index"]
-                            script_count = event_message.get("script_count", 10)
-
-                            if current_scripts:
-                                individual_script_data = {
-                                    "type": "individual_script",
-                                    "script_index": current_index,
-                                    "script_content": (
-                                        current_scripts[-1] if current_scripts else ""
-                                    ),
-                                    "progress": f"{current_index}/{script_count}",
-                                    "scripts": current_scripts,
-                                }
-                                yield f"data: {json.dumps(individual_script_data)}\n\n"
-
-                        yield f"data: {json.dumps(state_data, default=str)}\n\n"
-
-                except Exception as e:
-                    logger.error(f"Error processing event: {e}")
-                    error_data = {"type": "error", "message": str(e)}
-                    yield f"data: {json.dumps(error_data)}\n\n"
-
-        except Exception as e:
-            logger.error(f"Error in streaming: {e}")
-            error_data = {"type": "error", "message": str(e)}
-            yield f"data: {json.dumps(error_data)}\n\n"
-
-        # Send final result
-        if last_output_state:
-            final_data = {
-                "type": "final_result",
-                "scripts": last_output_state.get("script_writer_response", []),
-                "total_scripts": len(
-                    last_output_state.get("script_writer_response", [])
-                ),
-            }
-            yield f"data: {json.dumps(final_data, default=str)}\n\n"
-
-    except Exception as e:
-        logger.error(f"Fatal error in message_generator: {e}")
-        yield f"data: {json.dumps({'type': 'fatal_error', 'message': str(e)})}\n\n"
+                current_scripts = event_message["script_writer_response"]
+                current_index = event_message["current_script_index"]
+                script_count = event_message.get("script_count", 10)
+
+                if current_scripts:
+                    individual_script_data = {
+                        "type": "individual_script",
+                        "script_index": current_index,
+                        "script_content": (
+                            current_scripts[-1] if current_scripts else ""
+                        ),
+                        "progress": f"{current_index}/{script_count}",
+                        "scripts": current_scripts,
+                    }
+                    yield f"data: {json.dumps(individual_script_data)}\n\n"
+
+            yield f"data: {json.dumps(state_data, default=str)}\n\n"
+
+        # except Exception as e:
+        #     logger.error(f"Error processing event: {e}")
+        #     error_data = {"type": "error", "message": str(e)}
+        #     yield f"data: {json.dumps(error_data)}\n\n"
+
+    # except Exception as e:
+    #     logger.error(f"Error in streaming: {e}")
+    #     error_data = {"type": "error", "message": str(e)}
+    #     yield f"data: {json.dumps(error_data)}\n\n"
+
+    # Send final result
+    if last_output_state:
+        final_data = {
+            "type": "final_result",
+            "scripts": last_output_state.get("script_writer_response", []),
+            "total_scripts": len(last_output_state.get("script_writer_response", [])),
+        }
+        yield f"data: {json.dumps(final_data, default=str)}\n\n"
+
+    # except Exception as e:
+    #     logger.error(f"Fatal error in message_generator: {e}")
+    #     yield f"data: {json.dumps({'type': 'fatal_error', 'message': str(e)})}\n\n"
 
 
 @router.post("/gen-script")

src/utils/helper.py

@@ -178,12 +178,15 @@ def extract_transcript(video_link: str):
         raise
 
 
-
 def extract_comment(video_link: str):
-    ytd_api = YoutubeCommentDownloader()
-    comments = ytd_api.get_comments_from_url(video_link)
-    comments_str = ""
-    for comment in comments:
-        comments_str += comment["text"] + " "
-    logger.info(f"Comments: {comments_str}")
-    return comments_str
+    try:
+        ytd_api = YoutubeCommentDownloader()
+        comments = ytd_api.get_comments_from_url(video_link)
+        comments_str = ""
+        for comment in comments:
+            comments_str += comment["text"] + " "
+        logger.info(f"Comments: {comments_str}")
+        return comments_str
+    except Exception as e:
+        logger.error(f"Failed to extract comments: {str(e)}")
+        return ""