Upload 2 files

app_pages/video_hashid_generation.py

@@ -0,0 +1,68 @@
+import streamlit as st
+import tempfile
+from generator_function.video_hashid_function import process_video_with_hash_info
+# from database.operations import insert_video_hashid_result
+
+def render_video_hashid(uid: str):
+    st.markdown("#### Change video hashid")
+
+    uploaded_file = st.file_uploader(
+        "Choose a video file",
+        type=['mp4', 'avi', 'mov', 'mkv', 'wmv', 'flv', 'webm'],
+    )
+
+    generate_clicked = st.button(
+        "Generate Augmented Video",
+        type="primary",
+        use_container_width=True,
+        disabled=uploaded_file is None
+    )
+
+    result = None
+
+    if uploaded_file is not None:
+        st.success(f"File uploaded: {uploaded_file.name} ({uploaded_file.size / 1024 / 1024:.1f} MB)")
+
+        col1, col2 = st.columns([1, 1])
+
+        with col1:
+            st.markdown("### Original Video")
+            st.video(uploaded_file)
+
+        with col2:
+            st.markdown("### Augmented Video")
+
+            if generate_clicked:
+                with st.spinner("Processing video..."):
+                    with tempfile.NamedTemporaryFile(delete=False, suffix=f"_{uploaded_file.name}") as tmp_input:
+                        tmp_input.write(uploaded_file.getvalue())
+                        tmp_input_path = tmp_input.name
+
+                    with tempfile.TemporaryDirectory() as tmp_dir:
+                        result = process_video_with_hash_info(
+                            input_path=tmp_input_path,
+                            output_path=tmp_dir
+                        )
+
+                if result:
+                    st.video(result["output_r2_url"])
+                    st.markdown(f"**Input Hash ID:** `{result['input_hashid']}`")
+                    st.markdown(f"**Output Hash ID:** `{result['output_hashid']}`")
+
+                    st.download_button(
+                        "Download Augmented Video",
+                        data=open(result["output_path"], "rb").read(),
+                        file_name=result["output_name"],
+                        mime="video/mp4",
+                        use_container_width=True
+                    )
+
+
+                    # insert_video_hashid_result(
+                    #     video_name=uploaded_file.name,
+                    #     output_r2_url=result["output_r2_url"],
+                    #     output_hashid=result["output_hashid"],
+                    #     input_hashid=result["input_hashid"],
+                    #     thumbnail=result["thumbnail"],
+                    #     created_by=uid,
+                    # )

app_pages/video_text_generation.py

@@ -0,0 +1,65 @@
+import os, tempfile, logging
+import streamlit as st
+from dotenv import load_dotenv
+# from database.operations import insert_video_text_result
+from helpers_function.helpers import get_video_thumbnail_base64
+from generator_function.video_text_generator import extract_text_from_video
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+
+def render_video_to_text(uid: str = None):
+    st.subheader("Video → Text")
+
+    category = st.text_input("Category")
+    uploaded_file = st.file_uploader("Upload a video file", type=["mp4", "mov", "avi", "mkv"])
+
+    if uploaded_file:
+        st.video(uploaded_file)
+
+        if st.button("Convert to Text", width="content"):
+            with st.spinner("Processing video..."):
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp:
+                    tmp.write(uploaded_file.read())
+                    tmp_path = tmp.name
+
+                result = extract_text_from_video(tmp_path)
+
+                if not result or "error" in result:
+                    st.error(f"Error: {result.get('error', 'Unknown failure')}")
+                else:
+                    st.success("Video processed successfully!")
+                    
+                    # Display the extracted text
+                    if result and "text_output" in result:
+                        st.subheader("Extracted Text")
+                        st.text_area("Result", result["text_output"], height=200)
+                    else:
+                        st.warning("Text extraction was successful, but no text was found in the output.")
+
+                    st.session_state["video_to_text_result"] = result
+                    st.session_state["video_name"] = uploaded_file.name
+                    st.session_state["category"] = category
+                    try:
+                        st.session_state["thumbnail"] = get_video_thumbnail_base64(tmp_path) or ""
+                    except Exception as e:
+                        logger.warning(f"Thumbnail generation failed: {e}")
+                        st.session_state["thumbnail"] = ""
+
+                os.remove(tmp_path)
+
+        # if st.button("Save to DB", width="content", key="sg_save"):
+        #     try:
+        #         insert_video_text_result(
+        #             video_name=st.session_state.get("video_name", "unknown"),
+        #             response=st.session_state.get("video_to_text_result", {}),
+        #             thumbnail=st.session_state.get("thumbnail", ""),
+        #             created_by=uid,
+        #             category=st.session_state.get("category"),
+        #         )
+        #         st.success("Generated text saved to database ")
+        #     except Exception as e:
+        #         st.error(f"Failed to save generated text: {e}")