WIP with Codex

main.py

@@ -14,10 +14,11 @@ import torch
 from asr import Asr, AsrRawResult
 from asr_filter import AsrFilter, AsrFilterResult
 from asr_eventizer import AsrEventizer
+from structure_builder import StructureBuilder
 from windowizer import Windowizer
 
 from agent import Agent
-from utils import ffmpeg_split_video, ffmpeg_to_mp3
+from utils import Timeline, ffmpeg_split_video, ffmpeg_to_mp3
 
 ARGS: argparse.Namespace
 
@@ -170,6 +171,54 @@ def on_asr_events(current_step: Step, input_data: dict | None) -> tuple[Step | N
     result = eventizer.eventize(AsrFilterResult(**input_data))
     return (Step.VIDEO_REFERENCES, result.model_dump(mode="json"))
 
+def on_video_references(current_step: Step, input_data: dict | None) -> tuple[Step | None, dict | None]:
+    # do not filter if output file exists
+    if os.path.isfile(WORKFLOW_DATA[current_step][0]):
+        logging.info("Skipping video references")
+        with open(WORKFLOW_DATA[current_step][0], "rb") as f:
+            return (Step.REFERENCE_RESOLVER, json.load(f))
+    if not os.path.isfile("video.mp4"):
+        logging.info("No video, skipping")
+        return (Step.REFERENCE_RESOLVER, None)
+    # NOT IMPLEMENTED
+    logging.warning("Video references are not implemented yet")
+    return (Step.REFERENCE_RESOLVER, None)
+
+def on_reference_resolver(current_step: Step, input_data: dict | None) -> tuple[Step | None, dict | None]:
+    # do not filter if output file exists
+    if os.path.isfile(WORKFLOW_DATA[current_step][0]):
+        logging.info("Skipping reference resolver")
+        with open(WORKFLOW_DATA[current_step][0], "rb") as f:
+            return (Step.STRUCTURE_BUILDER, json.load(f))
+    if not os.path.isfile("video.mp4"):
+        logging.info("No video, skipping")
+        return (Step.STRUCTURE_BUILDER, input_data)
+    # NOT IMPLEMENTED
+    logging.warning("Reference resolver is not implemented yet")
+    return (Step.STRUCTURE_BUILDER, input_data)
+
+def on_structure_builder(current_step: Step, input_data: dict | None) -> tuple[Step | None, dict | None]:
+    # don't if done
+    if os.path.isfile(WORKFLOW_DATA[current_step][0]):
+        logging.info("Skipping structure builder")
+        with open(WORKFLOW_DATA[current_step][0], "rb") as f:
+            return (Step.MARKDOWN_BUILDER, json.load(f))
+    if input_data is None:
+        logging.error("Can't build document structure without input_data")
+        return (None, None)
+    logging.info("Creating the agent")
+    agent = Agent(
+        model=ARGS.ai_model,
+        base_url=ARGS.ai_base_url,
+        api_key=ARGS.ai_api_key
+    )
+    logging.info("Creating the windowizer")
+    windowizer = Windowizer()
+    logging.info("Building document structure...")
+    builder = StructureBuilder(agent, windowizer)
+    result = builder.build(Timeline(**input_data))
+    return (Step.MARKDOWN_BUILDER, result.model_dump(mode="json"))
+
 #
 # Main
 #
@@ -178,9 +227,9 @@ WORKFLOW_DATA: dict[Step, tuple[str, Callable[[Step, dict | None], tuple[Step |
     Step.VOICE_RECOGNITION: ("asr_raw.json", on_voice_recognition),
     Step.ASR_FILTER: ("asr.json", on_asr_filter),
     Step.ASR_EVENTS: ("audio_events.json", on_asr_events),
-    Step.VIDEO_REFERENCES: ("unresolved.json", None),
-    Step.REFERENCE_RESOLVER: ("events.json", None),
-    Step.STRUCTURE_BUILDER: ("structure.json", None),
+    Step.VIDEO_REFERENCES: ("unresolved.json", on_video_references),
+    Step.REFERENCE_RESOLVER: ("events.json", on_reference_resolver),
+    Step.STRUCTURE_BUILDER: ("structure.json", on_structure_builder),
     Step.MARKDOWN_BUILDER: ("output.md", None)
 }
 """Information about workflow.
@@ -224,4 +273,4 @@ if __name__ == "__main__":
     except SystemExit:
         raise
     except:
-        traceback.print_exc()
+        traceback.print_exc()