first commit

README.md

@@ -11,9 +11,57 @@ pinned: false
 short_description: Streamlit template space
 ---
 
-# Welcome to Streamlit!
+# SoraWithAzure: Streamlit Video Generation App
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+This app lets you generate videos using the Azure Sora API via a simple Streamlit interface. Users can enter a text prompt, select video settings, and generate videos that are stored and viewable by anyone using the app.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## Key Components
+
+- **SoraClient**: Handles all communication with the Azure Sora API (job creation, polling, download).
+- **VideoJob**: Represents a video generation job, encapsulating prompt, parameters, and result.
+- **VideoStorage**: Handles saving and listing generated videos in a persistent directory.
+- **Streamlit App**: Provides the user interface for input, video generation, and video display.
+
+## How it Works
+
+1. User enters their Azure API key, endpoint, and a text prompt.
+2. User selects video resolution, length, and number of variants.
+3. The app creates a video generation job via the Sora API.
+4. The app polls for job completion.
+5. When ready, the app downloads the generated video(s) and stores them.
+6. All generated videos are listed and playable in the app.
+
+## Sequence Diagram (ASCII)
+
+```
+User           StreamlitApp      SoraClient      AzureSoraAPI      VideoStorage
+ |                 |                |                |                |
+ |---input-------->|                |                |                |
+ |                 |---start_job--->|                |                |
+ |                 |                |---POST-------->|                |
+ |                 |                |<--job_id-------|                |
+ |                 |<--job_id-------|                |                |
+ |                 |---wait-------->|                |                |
+ |                 |                |---poll-------->|                |
+ |                 |                |<--status-------|                |
+ |                 |<--result-------|                |                |
+ |                 |---download---->|                |                |
+ |                 |                |---GET video--->|                |
+ |                 |                |<--video--------|                |
+ |                 |                |---save-------->|                |
+ |                 |                |<--file_path----|                |
+ |<---display------|                |                |                |
+```
+
+## Code Structure
+
+- `src/sora_video_downloader.py`: Core logic for Sora API interaction and video job management.
+- `src/streamlit_app.py`: Streamlit UI and app logic.
+
+## Notes
+- Only text-to-video is supported (no image+prompt).
+- All generated videos are visible to all users.
+
+---
+
+For more, see the code comments and docstrings in each file.

src/sora_video_downloader.log

@@ -0,0 +1,22 @@
+2025-08-12 09:22:53,468 - INFO - SoraClient initialized
+2025-08-12 09:22:54,028 - ERROR - Failed to start job: 400 {"error":{"code":"BadRequest","message":"API version not supported"}}
+2025-08-12 09:22:54,029 - ERROR - Failed to start video job
+2025-08-12 09:24:41,358 - INFO - SoraClient initialized
+2025-08-12 09:24:41,843 - ERROR - Failed to start job: 400 {"detail":"Resolution 2040x2040 is not supported. Supported resolutions are ((480, 480), (854, 480), (720, 720), (1280, 720), (1080, 1080), (1920, 1080))"}
+2025-08-12 09:24:41,843 - ERROR - Failed to start video job
+2025-08-12 09:26:02,313 - INFO - SoraClient initialized
+2025-08-12 10:14:56,702 - INFO - SoraClient initialized
+2025-08-12 10:14:57,191 - ERROR - Failed to start job: 401 {"error":{"code":"401","message":"Access denied due to invalid subscription key or wrong API endpoint. Make sure to provide a valid key for an active subscription and use a correct regional API endpoint for your resource."}}
+2025-08-12 10:14:57,191 - ERROR - Failed to start video job
+2025-08-12 10:15:24,555 - INFO - SoraClient initialized
+2025-08-12 10:15:25,014 - ERROR - Failed to start job: 400 {"detail":"Duration 30 is not supported. Duration should be between 1 and 20 seconds"}
+2025-08-12 10:15:25,015 - ERROR - Failed to start video job
+2025-08-12 10:15:34,058 - INFO - SoraClient initialized
+2025-08-12 10:15:34,496 - ERROR - Failed to start job: 400 {"detail":"Duration 20 currently is not supported for (1920, 1080)."}
+2025-08-12 10:15:34,496 - ERROR - Failed to start video job
+2025-08-12 10:22:18,027 - INFO - SoraClient initialized
+2025-08-12 10:22:18,468 - ERROR - Failed to start job: 401 {"error":{"code":"401","message":"Access denied due to invalid subscription key or wrong API endpoint. Make sure to provide a valid key for an active subscription and use a correct regional API endpoint for your resource."}}
+2025-08-12 10:22:18,469 - ERROR - Failed to start video job
+2025-08-12 10:22:35,442 - INFO - SoraClient initialized
+2025-08-12 10:25:58,756 - ERROR - Job failed or timed out
+2025-08-12 10:26:56,665 - INFO - SoraClient initialized

src/sora_video_downloader.py

@@ -0,0 +1,202 @@
+import os
+import time
+import json
+import logging
+import requests
+from typing import Optional, Dict, Any, List
+from urllib.parse import urlparse
+
+# --- Logging Setup ---
+def get_logger(name: str = __name__):
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s',
+            handlers=[
+                logging.FileHandler('sora_video_downloader.log'),
+                logging.StreamHandler()
+            ]
+        )
+    return logger
+
+logger = get_logger()
+
+# --- Sora API Client ---
+class SoraClient:
+    def __init__(self, api_key: str, base_url: str, api_version: str = "preview"):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip('/')
+        self.api_version = api_version
+        self.session = requests.Session()
+        self.session.headers.update({
+            'api-key': self.api_key,
+            'Content-Type': 'application/json'
+        })
+        logger.info("SoraClient initialized")
+
+    def start_video_job(self, prompt: str, height: int = 1080, width: int = 1080, n_seconds: int = 5, n_variants: int = 1) -> Optional[str]:
+        url = f"{self.base_url}/openai/v1/video/generations/jobs?api-version={self.api_version}"
+        payload = {
+            "model": "sora",
+            "prompt": prompt,
+            "height": str(height),
+            "width": str(width),
+            "n_seconds": str(n_seconds),
+            "n_variants": str(n_variants)
+        }
+        try:
+            response = self.session.post(url, json=payload)
+            if response.status_code in [200, 201, 202]:
+                result = response.json()
+                job_id = result.get('id') or result.get('job_id') or result.get('jobId')
+                return job_id
+            else:
+                logger.error(f"Failed to start job: {response.status_code} {response.text}")
+                return None
+        except Exception as e:
+            logger.error(f"Exception in start_video_job: {e}")
+            return None
+
+    def get_job_status(self, job_id: str) -> Dict[str, Any]:
+        url = f"{self.base_url}/openai/v1/video/generations/jobs/{job_id}?api-version={self.api_version}"
+        try:
+            response = self.session.get(url)
+            if response.status_code == 200:
+                return response.json()
+            else:
+                logger.error(f"Failed to get job status: {response.status_code} {response.text}")
+                return {"status": "error", "error": f"HTTP {response.status_code}"}
+        except Exception as e:
+            logger.error(f"Exception in get_job_status: {e}")
+            return {"status": "error", "error": str(e)}
+
+    def wait_for_job(self, job_id: str, max_wait_time: int = 300, poll_interval: int = 10) -> Optional[Dict[str, Any]]:
+        start_time = time.time()
+        while time.time() - start_time < max_wait_time:
+            status_result = self.get_job_status(job_id)
+            status = status_result.get('status', '').lower()
+            if status in ['completed', 'succeeded', 'success']:
+                return status_result
+            elif status in ['failed', 'error']:
+                return None
+            time.sleep(poll_interval)
+        logger.error(f"Job {job_id} timed out after {max_wait_time}s")
+        return None
+
+    def get_generation_details(self, generation_id: str) -> Dict[str, Any]:
+        url = f"{self.base_url}/openai/v1/video/generations/{generation_id}?api-version={self.api_version}"
+        try:
+            resp = self.session.get(url)
+            if resp.status_code == 200:
+                return resp.json()
+            else:
+                logger.error(f"Failed to fetch generation details: HTTP {resp.status_code}")
+                return {}
+        except Exception as e:
+            logger.error(f"Exception in get_generation_details: {e}")
+            return {}
+
+    def extract_video_urls(self, job_result: Dict[str, Any]) -> List[str]:
+        video_urls = []
+        generations = job_result.get('generations', [])
+        if isinstance(generations, list) and generations:
+            for g in generations:
+                gen_id = g.get('id') if isinstance(g, dict) else None
+                if not gen_id:
+                    continue
+                content_url = f"{self.base_url}/openai/v1/video/generations/{gen_id}/content/video?api-version={self.api_version}"
+                video_urls.append(content_url)
+        return video_urls
+
+    def download_video(self, video_url: str, output_filename: str) -> bool:
+        try:
+            download_session = requests.Session()
+            download_session.headers.update({'api-key': self.api_key})
+            response = download_session.get(video_url, stream=True)
+            if response.status_code == 200:
+                with open(output_filename, 'wb') as f:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        if chunk:
+                            f.write(chunk)
+                return True
+            else:
+                logger.error(f"Failed to download video: {response.status_code} {response.text}")
+                return False
+        except Exception as e:
+            logger.error(f"Exception in download_video: {e}")
+            return False
+
+# --- Video Job Abstraction ---
+class VideoJob:
+    def __init__(self, sora_client: SoraClient, prompt: str, height: int = 1080, width: int = 1080, n_seconds: int = 5, n_variants: int = 1):
+        self.sora_client = sora_client
+        self.prompt = prompt
+        self.height = height
+        self.width = width
+        self.n_seconds = n_seconds
+        self.n_variants = n_variants
+        self.job_id: Optional[str] = None
+        self.result: Optional[Dict[str, Any]] = None
+        self.video_urls: List[str] = []
+
+    def run(self, wait: bool = True) -> bool:
+        self.job_id = self.sora_client.start_video_job(
+            self.prompt, self.height, self.width, self.n_seconds, self.n_variants
+        )
+        if not self.job_id:
+            logger.error("Failed to start video job")
+            return False
+        if wait:
+            self.result = self.sora_client.wait_for_job(self.job_id)
+            if not self.result:
+                logger.error("Job failed or timed out")
+                return False
+            self.video_urls = self.sora_client.extract_video_urls(self.result)
+            if not self.video_urls:
+                logger.error("No video URLs found")
+                return False
+        return True
+
+    def download_videos(self, output_dir: str) -> List[str]:
+        saved_files = []
+        for i, url in enumerate(self.video_urls):
+            filename = f"sora_video_{self.job_id}_{i+1}.mp4"
+            filepath = os.path.join(output_dir, filename)
+            if self.sora_client.download_video(url, filepath):
+                saved_files.append(filepath)
+        return saved_files
+
+# --- Video Storage Handler ---
+class VideoStorage:
+    def __init__(self, storage_dir: str = "videos"):
+        self.storage_dir = storage_dir
+        os.makedirs(self.storage_dir, exist_ok=True)
+
+    def save_video(self, src_path: str, filename: str) -> str:
+        dst_path = os.path.join(self.storage_dir, filename)
+        os.rename(src_path, dst_path)
+        return dst_path
+
+    def list_videos(self) -> List[str]:
+        return [os.path.join(self.storage_dir, f) for f in os.listdir(self.storage_dir) if f.endswith('.mp4')]
+
+# --- Main for CLI usage (optional) ---
+def main():
+    api_key = os.getenv('AZURE_OPENAI_API_KEY') or os.getenv('AZURE_API_KEY')
+    base_url = os.getenv('AZURE_OPENAI_ENDPOINT') or "https://levm3-me7f7pgq-eastus2.cognitiveservices.azure.com"
+    if not api_key or not base_url:
+        print("Please set your Azure API key and endpoint.")
+        return
+    sora = SoraClient(api_key, base_url)
+    prompt = "A video of a cat playing with a ball of yarn in a sunny room"
+    job = VideoJob(sora, prompt)
+    if job.run():
+        storage = VideoStorage()
+        files = job.download_videos(storage.storage_dir)
+        print(f"Downloaded: {files}")
+    else:
+        print("Video generation failed.")
+
+if __name__ == "__main__":
+    main()

src/streamlit_app.py

@@ -1,40 +1,84 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
+"""
+Streamlit app for generating videos using Azure Sora API.
 
+- Users provide an API key, endpoint, and a text prompt.
+- Advanced settings allow selection of video resolution, length, and number of variants.
+- Generated videos are stored and displayed for all users.
 """
-# Welcome to Streamlit!
+import streamlit as st
+import os
+from sora_video_downloader import SoraClient, VideoJob, VideoStorage
 
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# --- Hardcoded for testing, but can be made user-editable ---
+DEFAULT_API_KEY = os.getenv('AZURE_OPENAI_API_KEY', 'YOUR_AZURE_API_KEY')
+DEFAULT_ENDPOINT = os.getenv('AZURE_OPENAI_ENDPOINT', 'https://levm3-me7f7pgq-eastus2.cognitiveservices.azure.com')
 
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
+# --- UI: Title and Sidebar ---
+st.title("Sora Video Generator (Azure)")
+
+st.sidebar.header("Azure Sora Settings")
+api_key = st.sidebar.text_input("API Key", value=DEFAULT_API_KEY, type="password")
+endpoint = st.sidebar.text_input("Azure AI Foundry Endpoint", value=DEFAULT_ENDPOINT)
+
+# --- UI: Main Input ---
+st.header("Generate a Video with Sora")
+prompt = st.text_area("Video Prompt", "A video of a cat playing with a ball of yarn in a sunny room")
+
+# --- UI: Advanced Settings ---
+st.subheader("Advanced Settings")
+col1, col2 = st.columns(2)
+
+DURATION_RES_MAP = {
+    5: [
+        (480, 480), (854, 480), (720, 720), (1280, 720), (1080, 1080), (1920, 1080)
+    ],
+    10: [
+        (480, 480), (854, 480), (720, 720), (1280, 720), (1080, 1080)
+    ],
+    20: [
+        (480, 480), (854, 480), (720, 720), (1280, 720)
+    ]
+}
+
+with col1:
+    n_seconds = st.selectbox("Video Length (seconds)", options=[5, 10, 20], index=0)
+    valid_resolutions = DURATION_RES_MAP[n_seconds]
+    res_labels = [f"{w}x{h}" for (w, h) in valid_resolutions]
+    res_idx = st.selectbox("Resolution", options=list(range(len(res_labels))), format_func=lambda i: res_labels[i], index=0)
+    width, height = valid_resolutions[res_idx]
+with col2:
+    n_variants = st.slider("Number of Variants", min_value=1, max_value=4, value=1)
+
+# --- Video Generation Logic ---
+generate = st.button("Generate Video")
+status_placeholder = st.empty()
+
+video_storage = VideoStorage()
+
+if generate:
+    # Validate required fields
+    if not api_key or not endpoint or not prompt.strip():
+        st.error("Please provide all required fields.")
+    else:
+        status_placeholder.info("Starting video generation...")
+        sora = SoraClient(api_key, endpoint)
+        job = VideoJob(sora, prompt, height=height, width=width, n_seconds=n_seconds, n_variants=n_variants)
+        if job.run():
+            saved_files = job.download_videos(video_storage.storage_dir)
+            if saved_files:
+                status_placeholder.success(f"Video(s) generated and saved: {', '.join([os.path.basename(f) for f in saved_files])}")
+            else:
+                status_placeholder.error("Video generation succeeded but download failed.")
+        else:
+            status_placeholder.error("Video generation failed.")
 
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# --- Display All Generated Videos ---
+st.header("All Generated Videos")
+video_files = video_storage.list_videos()
+if not video_files:
+    st.info("No videos generated yet.")
+else:
+    for video_path in sorted(video_files, reverse=True):
+        st.video(video_path)
+        st.caption(os.path.basename(video_path))
+        st.download_button("Download", data=open(video_path, "rb").read(), file_name=os.path.basename(video_path), mime="video/mp4")