Automated UV deployment

=0.1.4

@@ -23,9 +23,9 @@ Requirement already satisfied: sniffio>=1.1 in /opt/hostedtoolcache/Python/3.12.
 Requirement already satisfied: click>=8.0.0 in /opt/hostedtoolcache/Python/3.12.12/x64/lib/python3.12/site-packages (from typer-slim->huggingface-hub>=0.30) (8.2.1)
 Downloading huggingface_hub-1.1.2-py3-none-any.whl (514 kB)
 Downloading hf_xet-1.2.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.3 MB)
-   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 3.3/3.3 MB 138.8 MB/s  0:00:00
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 3.3/3.3 MB 164.4 MB/s  0:00:00
 Downloading hf_transfer-0.1.9-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.6 MB)
-   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 3.6/3.6 MB 231.0 MB/s  0:00:00
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 3.6/3.6 MB 354.7 MB/s  0:00:00
 Downloading typer_slim-0.20.0-py3-none-any.whl (47 kB)
 Installing collected packages: typer-slim, hf-xet, hf-transfer, huggingface-hub
 

Dockerfile

@@ -25,7 +25,7 @@ RUN python -m pip install --upgrade pip setuptools wheel \
     && pip install --no-cache-dir -r requirements.txt
 
 # Copy the entire project structure
-COPY app/ ./app/
+COPY files/ ./files/
 COPY ui/ ./ui/
 COPY config.py ./config.py
 COPY __init__.py ./

files/pipeline/audio_analysis.py

@@ -0,0 +1,185 @@
+import os
+import json
+import ffmpeg
+import whisper
+import subprocess
+import base64
+from pathlib import Path
+from typing import Dict, List
+import google.generativeai as genai
+
+from config import make_path, GEMINI_API_KEY
+from files.utils.logging import get_logger
+
+
+class AudioAnalyzer:
+    def __init__(self, video_path: str, gemini_api_key: str = "", model_size: str = 'small'):
+        self.model_size = model_size
+        self.video_path = Path(video_path)
+        self.audio_path = make_path('interim/audio', video_path, 'audio', 'wav')
+        self.json_out = make_path('processed/audio-analysis', video_path, 'audio_analysis', 'json')
+        self.logger = get_logger('audio_analysis', f'{self.video_path.stem}_log.txt')
+
+        # ✅ Set Gemini key (explicit or from environment)
+        if gemini_api_key:
+            genai.configure(api_key=gemini_api_key)
+        else:
+            genai.configure(api_key=os.getenv("GEMINI_API_KEY", ""))
+        self.llm_model = genai.GenerativeModel('gemini-2.5-pro')
+
+    def _extract_audio(self) -> None:
+        self.audio_path.parent.mkdir(parents=True, exist_ok=True)
+        (
+            ffmpeg
+            .input(str(self.video_path))
+            .output(str(self.audio_path), ac=1, ar='16k', format='wav', loglevel='quiet')
+            .overwrite_output()
+            .run()
+        )
+        self.logger.info('Audio extracted to %s', self.audio_path)
+
+    def _transcribe(self) -> Dict:
+        model = whisper.load_model(self.model_size)
+        return model.transcribe(str(self.audio_path), fp16=False)
+
+    def _loudness_stats(self, audio_path: Path) -> Dict:
+        cmd = [
+            'ffmpeg', '-i', str(audio_path),
+            '-af', 'volumedetect',
+            '-f', 'null', 'NUL' if os.name == 'nt' else '/dev/null'
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        mean = peak = None
+        for line in result.stderr.splitlines():
+            if 'mean_volume:' in line:
+                mean = float(line.split('mean_volume:')[1].split()[0])
+            if 'max_volume:' in line:
+                peak = float(line.split('max_volume:')[1].split()[0])
+        return {'loudness_mean': mean, 'loudness_peak': peak}
+
+    def _load_visual_context(self) -> Dict:
+        """Load nearby frames and brightness values from extracted frame data."""
+        frame_json_path = make_path('processed/scene-detection', self.video_path, 'scene', 'json')
+        frames_dir = make_path('interim/frames', self.video_path, '', '')
+
+        if not frame_json_path.exists():
+            self.logger.warning("Frame metadata not found: %s", frame_json_path)
+            return {}
+
+        with open(frame_json_path, 'r', encoding='utf-8') as f:
+            scene_data = json.load(f)
+
+        if not scene_data.get('scenes'):
+            return {}
+
+        scene = scene_data['scenes'][0]
+        mid_time = (float(scene['start_time']) + float(scene['end_time'])) / 2
+        scene_idx = 0
+
+        def get_frame_path(tag):
+            return frames_dir / f"{self.video_path.stem}_scene_{scene_idx:02}{tag}.jpg"
+
+        def encode_image(p: Path) -> str:
+            if p.exists():
+                with open(p, 'rb') as f:
+                    return base64.b64encode(f.read()).decode('utf-8')
+            return ""
+
+        return {
+            'mid_time': mid_time,
+            'frame': encode_image(get_frame_path('')),
+            'prev': encode_image(get_frame_path('_prev')),
+            'next': encode_image(get_frame_path('_next')),
+            'brightness': float(scene.get('brightness', -1.0))
+        }
+
+    def _gemini_audio_analysis(self, text: str, loudness: Dict, wps: float, visuals: Dict) -> Dict:
+        """LLM-enhanced audio analysis using audio + first scene frames + metadata"""
+        prompt = f"""
+        You are an expert video analyst. Based on the transcript, loudness, speaking pace,
+        and the first scene's frames (prev, current, next), analyze the audio tone.
+
+        Answer in JSON only:
+        {{
+        "tone": "calm|excited|angry|funny|sad|neutral",
+        "emotion": "joy|sadness|anger|surprise|neutral|mixed",
+        "pace": "fast|medium|slow",
+        "delivery_score": 0-100,
+        "is_hooking_start": true|false,
+        "comment": "brief summary of audio performance",
+        "is_dark_artistic": true|false,
+        "brightness": 0-100
+        }}
+
+        Transcript: {text}
+        Loudness: {json.dumps(loudness)}
+        Words/sec: {wps}
+        Frame brightness: {visuals.get('brightness')}
+        """
+
+        # ✅ Properly formatted parts for Gemini multimodal prompt
+        parts = [{"text": prompt}]
+        for tag in ['prev', 'frame', 'next']:
+            img_b64 = visuals.get(tag)
+            if img_b64:
+                parts.append({
+                    "inline_data": {
+                        "mime_type": "image/jpeg",
+                        "data": base64.b64decode(img_b64),
+                    }
+                })
+
+        try:
+            response = self.llm_model.generate_content(
+                contents=[{"role": "user", "parts": parts}],
+                generation_config={'temperature': 0.3}
+            )
+            text = getattr(response, 'text', '').strip()
+            cleaned = text.replace('```json', '').replace('```', '')
+            return json.loads(cleaned)
+        except Exception as e:
+            error_msg = str(e)
+            self.logger.error("LLM call failed: %s", e)
+            
+            # Check if it's an API key error - if so, raise it to stop the pipeline
+            if any(keyword in error_msg.lower() for keyword in ["api_key", "invalid", "401", "403", "authentication", "unauthorized"]):
+                raise ValueError(f"Invalid Gemini API key: {error_msg}") from e
+            
+            # For other errors, return defaults but log the issue
+            return {
+                "tone": "neutral",
+                "emotion": "neutral",
+                "pace": "medium",
+                "delivery_score": 50,
+                "is_hooking_start": False,
+                "comment": "LLM analysis failed, using defaults",
+                "is_dark_artistic": False,
+                "brightness": visuals.get("brightness", -1.0)
+            }
+
+    def analyze(self) -> Dict:
+        self._extract_audio()
+        whisper_res = self._transcribe()
+        full_text = whisper_res['text']
+        duration_s = whisper_res['segments'][-1]['end'] if whisper_res['segments'] else 0
+        wps = round(len(full_text.split()) / duration_s, 2) if duration_s else 0
+
+        loudness = self._loudness_stats(self.audio_path)
+        visual_context = self._load_visual_context()
+        gemini_analysis = self._gemini_audio_analysis(full_text, loudness, wps, visual_context)
+
+        result = {
+            'full_transcript': full_text,
+            'duration_seconds': duration_s,
+            'word_count': len(full_text.split()),
+            'words_per_second': wps,
+            **loudness,
+            **gemini_analysis
+        }
+
+        self.json_out.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.json_out, 'w', encoding='utf-8') as f:
+            json.dump(result, f, indent=2)
+
+        self.logger.info('Audio + Visual LLM analysis saved to %s', self.json_out)
+        return result

files/pipeline/frame_analysis.py

@@ -0,0 +1,195 @@
+import os
+import re
+import json
+import base64
+import openai
+from pathlib import Path
+import google.generativeai as genai
+from files.utils.logging import get_logger
+from config import make_path, OPENAI_API_KEY, GEMINI_API_KEY, DATA_DIR
+
+
+class FrameAnalyzer:
+    def __init__(self, video_path: str, openai_api_key: str = "", save_dir: str = 'processed/frame-analysis'):
+        # ✅ Set OpenAI key (explicit or from environment)
+        
+        # print(openai_api_key)
+
+        if openai_api_key:
+            openai.api_key = openai_api_key
+        else:
+            import os
+            openai.api_key = os.getenv("OPENAI_API_KEY")
+
+        self.video_path = Path(video_path)
+        self.frames_dir = DATA_DIR / 'interim' / 'frames' / f'{self.video_path.stem}_'
+        self.save_path = make_path(save_dir, video_path, 'frame_analysis', 'json')
+        self.save_path.parent.mkdir(parents=True, exist_ok=True)
+
+        log_file = f'{self.video_path.stem}_log.txt'
+        self.logger = get_logger('frame_analysis', log_file)
+
+    @staticmethod
+    def encode_image(path: Path) -> str:
+        with open(path, 'rb') as f:
+            return base64.b64encode(f.read()).decode('utf-8')
+
+    @staticmethod
+    def extract_json(text: str) -> dict:
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            pass
+
+        match = re.search(r'```json\s*(\{.*?\})\s*```', text, re.DOTALL)
+        if match:
+            return json.loads(match.group(1))
+
+        match = re.search(r'(\{.*?\})', text, re.DOTALL)
+        if match:
+            return json.loads(match.group(1))
+
+        raise ValueError('No valid JSON found in GPT response')
+
+    def gpt_analyze(self, frame_path: Path, prev_path: Path, next_path: Path) -> dict:
+        prompt = """
+        You are an expert video content strategist. Analyze this video frame and surrounding context. 
+        Determine if the lighting is poor or intentionally low for creative reasons. 
+
+        Output JSON only:
+        {
+          lighting: 0-100,
+          is_artistic_dark: true|false,
+          composition: 0-100,
+          has_text: true|false,
+          text: "string",
+          hook_strength: 0-100
+        }
+        """
+
+        images = [
+            {'type': 'image_url', 'image_url': {'url': f'data:image/jpeg;base64,{self.encode_image(p)}'}}
+            for p in [prev_path, frame_path, next_path] if p.exists()
+        ]
+
+        response = openai.chat.completions.create(
+            model='gpt-4o-mini',
+            messages=[
+                {'role': 'user', 'content': [{'type': 'text', 'text': prompt}] + images}
+            ],
+            temperature=0.2,
+            max_tokens=400,
+        )
+        return self.extract_json(response.choices[0].message.content)
+
+    def analyze(self) -> dict:
+        results = {}
+        all_frames = sorted(self.frames_dir.glob('*_scene_*.jpg'))
+        center_frames = [f for f in all_frames if '_prev' not in f.name and '_next' not in f.name]
+
+        for frame in center_frames:
+            prev = frame.with_name(frame.name.replace('.jpg', '_prev.jpg'))
+            next_ = frame.with_name(frame.name.replace('.jpg', '_next.jpg'))
+
+            self.logger.info('Analyzing frame: %s', frame.name)
+            try:
+                result = self.gpt_analyze(frame, prev, next_)
+                results[frame.name] = result
+            except Exception as e:
+                self.logger.error('LLM analysis failed on %s: %s', frame.name, e)
+                results[frame.name] = {'error': str(e)}
+
+        with open(self.save_path, 'w', encoding='utf-8') as f:
+            json.dump(results, f, indent=2)
+
+        self.logger.info('Frame analysis saved to %s', self.save_path)
+        return results
+
+class HookAnalyzer:
+    def __init__(self, video_path: str, gemini_api_key: str = ""):
+        self.video_path = Path(video_path)
+        self.frames_dir = Path('data/interim/frames') / f'{self.video_path.stem}_'
+        self.audio_json = make_path('processed/audio-analysis', video_path, 'audio_analysis', 'json')
+        self.output_json = make_path('processed/hook-analysis', video_path, 'hook_analysis', 'json')
+        self.logger = get_logger('hook_analysis', f'{self.video_path.stem}_log.txt')
+
+        # ✅ Set Gemini key (explicit or from environment)
+        if gemini_api_key:
+            genai.configure(api_key=gemini_api_key)
+        else:
+            genai.configure(api_key=os.getenv("GEMINI_API_KEY", ""))
+        self.model = genai.GenerativeModel('gemini-2.5-pro')
+
+    def _encode_image(self, path: Path) -> bytes:
+        with open(path, 'rb') as f:
+            return f.read()
+
+    def _load_audio_summary(self) -> dict:
+        with open(self.audio_json, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+    def _gemini_hook_alignment(self, audio_summary: dict, frames: list[Path]) -> dict:
+        parts = [{'mime_type': 'image/jpeg', 'data': self._encode_image(f)} for f in frames if f.exists()]
+        text = f"""You are a virality analyst. Analyze the opening visuals and tone:
+        - Does the audio mood match the expressions and visuals?
+        - Are viewers likely to be hooked in the first few seconds?
+
+        Audio Summary: {json.dumps(audio_summary)}
+
+        Give JSON only:
+        {{
+        "hook_alignment_score": 0-100,
+        "facial_sync": "good|ok|poor|none",
+        "comment": "short summary"
+        }}"""
+
+        try:
+            response = self.model.generate_content([text] + parts)
+            raw_text = getattr(response, 'text', '').strip()
+            self.logger.debug("Gemini raw response: %s", raw_text)
+            if not raw_text:
+                raise ValueError("Gemini response was empty.")
+            
+            raw_text = (
+                raw_text
+                .replace('```json\n', '')
+                .replace('\n```', '')
+                .replace('```json', '')
+                .replace('```', '')
+            )
+
+            return json.loads(raw_text)
+        except json.JSONDecodeError as e:
+            self.logger.error("❌ Failed to parse Gemini response as JSON: %s", e)
+            self.logger.debug("Gemini response was: %r", getattr(response, 'text', '<<NO TEXT>>'))
+            return {
+                "hook_alignment_score": -1,
+                "facial_sync": "none",
+                "comment": "Invalid JSON response from Gemini"
+            }
+        except Exception as e:
+            error_msg = str(e)
+            self.logger.error("❌ Gemini API call failed: %s", e)
+            
+            # Check if it's an API key error - if so, raise it to stop the pipeline
+            if any(keyword in error_msg.lower() for keyword in ["api_key", "invalid", "401", "403", "authentication", "unauthorized"]):
+                raise ValueError(f"Invalid Gemini API key: {error_msg}") from e
+            
+            # For other errors, return defaults
+            return {
+                "hook_alignment_score": -1,
+                "facial_sync": "none",
+                "comment": f"Gemini API error: {error_msg}"
+            }
+
+    def analyze(self) -> dict:
+        audio_summary = self._load_audio_summary()
+        frames = sorted(self.frames_dir.glob('*_scene_*.jpg'))[:3]
+        result = self._gemini_hook_alignment(audio_summary, frames)
+
+        self.output_json.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.output_json, 'w', encoding='utf-8') as f:
+            json.dump(result, f, indent=2)
+
+        self.logger.info('Hook analysis saved to %s', self.output_json)
+        return result

files/pipeline/frame_extract.py

@@ -0,0 +1,99 @@
+import json
+import subprocess
+from pathlib import Path
+from config import make_path
+from files.utils.logging import get_logger
+
+
+class FrameExtractor:
+    def __init__(self, video_path: str, min_scene_len: float = 0.2):
+        self.min_scene_len = min_scene_len
+        self.video_path = Path(video_path)
+        self.scene_json_path = self.frame_json = make_path('processed/scene-detection', video_path, 'scene', 'json')
+        self.output_dir = make_path('interim/frames', video_path, '', '')
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        log_file = f'{self.video_path.stem}_log.txt'
+        self.logger = get_logger('frame_extract', log_file)
+
+    def _ffmpeg_extract(self, timestamp: float, out_path: Path):
+        cmd = [
+            'ffmpeg',
+            '-loglevel', 'error',
+            '-y',
+            '-ss', f'{timestamp:.3f}',
+            '-t', '1',
+            '-i', str(self.video_path),
+            '-frames:v', '1',
+            '-q:v', '2',
+            '-pix_fmt', 'yuvj420p',
+            str(out_path)
+        ]
+        result = subprocess.run(cmd, capture_output=True)
+        if result.returncode != 0:
+            self.logger.error('ffmpeg failed: %s', result.stderr.decode('utf-8', 'ignore').strip())
+
+    def _get_brightness(self, timestamp: float) -> float:
+        cmd = [
+            'ffprobe',
+            '-v', 'error',
+            '-read_intervals', f'%{timestamp}+1',
+            '-select_streams', 'v:0',
+            '-show_frames',
+            '-show_entries', 'frame_tags=lavfi.signalstats.YAVG',
+            '-of', 'default=noprint_wrappers=1:nokey=1',
+            str(self.video_path)
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        try:
+            yavg_values = [float(line.strip()) for line in result.stdout.strip().split('\n') if line.strip()]
+            if yavg_values:
+                return yavg_values[0]
+        except Exception:
+            pass
+        self.logger.warning('Could not get brightness at %.2fs', timestamp)
+        return -1.0
+
+    def extract(self) -> list[dict]:
+        with open(self.scene_json_path, encoding='utf-8') as f:
+            scenes = json.load(f).get('scenes', [])
+        if not scenes:
+            self.logger.warning('No scenes found in %s', self.scene_json_path)
+            return []
+
+        delta = 0.5
+        results = []
+
+        for i, sc in enumerate(scenes):
+            start = float(sc['start_time'])
+            end = float(sc['end_time'])
+            dur = end - start
+            if dur < self.min_scene_len:
+                self.logger.warning('Scene %s too short (%.2fs), skipping', i, dur)
+                continue
+
+            mid = (start + end) / 2
+
+            frame_path = self.output_dir / f'{self.video_path.stem}_scene_{i:02}.jpg'
+            prev_path = self.output_dir / f'{self.video_path.stem}_scene_{i:02}_prev.jpg'
+            next_path = self.output_dir / f'{self.video_path.stem}_scene_{i:02}_next.jpg'
+
+            self._ffmpeg_extract(mid, frame_path)
+            self._ffmpeg_extract(mid - delta, prev_path)
+            self._ffmpeg_extract(mid + delta, next_path)
+
+            brightness = self._get_brightness(mid)
+
+            self.logger.info('[Scene %s] %.2fs → %s | Brightness: %.2f', i, mid, frame_path.name, brightness)
+
+            results.append({
+                'scene_index': i,
+                'timestamp': mid,
+                'frame_path': str(frame_path),
+                'prev_frame_path': str(prev_path),
+                'next_frame_path': str(next_path),
+                'brightness': brightness
+            })
+
+        self.logger.info('%s frames (with context) extracted to %s', len(results), self.output_dir)
+        return results

files/pipeline/scene_detect.py

@@ -0,0 +1,64 @@
+import os
+import json
+from pathlib import Path
+from scenedetect import VideoManager, SceneManager
+from scenedetect.detectors import ContentDetector
+from files.utils.logging import get_logger
+from config import make_path
+
+
+class SceneDetector:
+    def __init__(self, video_path: str, backend='base', return_scenes=False,
+                 min_scene_duration=0.1, threshold=30.0, transition_merge_gap=0.1):
+        self.video_path = video_path
+        self.backend = backend
+        self.return_scenes = return_scenes
+        self.min_scene_duration = min_scene_duration
+        self.threshold = threshold
+        self.transition_merge_gap = transition_merge_gap
+
+        log_filename = f'{Path(video_path).stem}_log.txt'
+        self.logger = get_logger(name='scene_detect', log_file=log_filename)
+
+    def detect(self, start_time: float = 0, end_time: float = -1) -> list:
+        try:
+            self.logger.info(f'Detecting scenes for: {self.video_path}')
+
+            video_manager = VideoManager([self.video_path])
+            scene_manager = SceneManager()
+            scene_manager.add_detector(ContentDetector(threshold=self.threshold))
+
+            video_manager.set_downscale_factor()
+            video_manager.start()
+            scene_manager.detect_scenes(frame_source=video_manager)
+            scene_list = scene_manager.get_scene_list()
+
+            # Format output to match Sieve style
+            scenes = []
+            for start, end in scene_list:
+                scenes.append({
+                    "start": round(start.get_seconds(), 2),
+                    "end": round(end.get_seconds(), 2)
+                })
+
+            self.logger.info(f"{len(scenes)} scenes detected.")
+            return [{"scenes": scenes}]
+
+        except Exception as e:
+            self.logger.error(f'Scene detection failed: {e}')
+            return []
+
+    def detect_and_save(self) -> list:
+        scenes = self.detect()
+        if not scenes:
+            self.logger.warning('No scenes detected. Skipping save.')
+            return []
+
+        out_path = make_path('processed/scene-detection', self.video_path, 'scene', 'json')
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(out_path, 'w', encoding='utf-8') as f:
+            json.dump({'scenes': scenes[0]['scenes']}, f, indent=2)
+
+        self.logger.info(f'Scene data saved to: {out_path}')
+        return scenes

files/pipeline/scoring.py

@@ -0,0 +1,202 @@
+import openai
+import json
+from pathlib import Path
+from files.utils.logging import get_logger
+from config import make_path, OPENAI_API_KEY
+
+
+class VideoReport:
+    def __init__(self, video_path: str, openai_api_key: str = ""):
+        # ✅ Set OpenAI key (explicit or from environment)
+        if openai_api_key:
+            openai.api_key = openai_api_key
+        else:
+            import os
+            openai.api_key = os.getenv("OPENAI_API_KEY", "")
+        self.video_path = Path(video_path)
+        self.audio_json = make_path('processed/audio-analysis', video_path, 'audio_analysis', 'json')
+        self.frame_json = make_path('processed/frame-analysis', video_path, 'frame_analysis', 'json')
+        self.hook_json = make_path('processed/hook-analysis', video_path, 'hook_analysis', 'json')
+        self.output_json = make_path('reports', video_path, 'final_report', 'json')
+
+        log_filename = f'{self.video_path.stem}_log.txt'
+        self.logger = get_logger(name='video_report', log_file=log_filename)
+
+        self.audio_analysis = self.load_json(self.audio_json)
+        self.frame_analysis = self.load_json(self.frame_json)
+        self.hook_analysis = self.load_json(self.hook_json)
+
+    def load_json(self, path: Path):
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception:
+            return {}
+
+    def extract_matrices(self):
+        return {
+            "tone": self.audio_analysis.get("tone", "unknown"),
+            "emotion": self.audio_analysis.get("emotion", "unknown"),
+            "pace": self.audio_analysis.get("pace", "unknown"),
+            "facial_sync": self.hook_analysis.get("facial_sync", "unknown")
+        }
+
+    def prepare_prompt(self) -> str:
+        prompt_sections = []
+        prompt_sections.append(f"""
+        You are an expert evaluator trained to assess the **virality potential and content quality** of short-form video ads (e.g., TikToks, Reels). You are provided with:
+
+        - A sequence of scene-selected **frames**
+        - A full **audio transcription**
+        - Detailed **audio statistics**
+        - And other meta-data of videos
+                                
+        Your task is to analyze the video and assign the **five scores** with weighted importance. Follow the criteria and format strictly.
+                                
+        ---
+                                
+        ### 🎯 Scores to Judge (Each 0–100)
+
+        You must evaluate the following sub-categories:
+
+        - `hook`: Does the video grab attention in the first 3 seconds? A good hook is **surprising, emotional, funny, or visually intense**. A poor hook is **slow, random, or bland**.
+        
+        - `visuals`: Are visuals high-resolution, diverse, and relevant to the message? Good visuals are **intentional and professionally framed**. Poor visuals are **static, noisy, or irrelevant**.
+        
+        - `audio`: Is the audio clean, engaging, and well-synced? Quality audio has **clarity, proper levels, and supports the visuals**. Poor audio is **distracting, flat, or off-sync**.
+        
+        - `engagement`: Does the video maintain interest? Strong pacing, emotional depth, or thought-provoking content improves this. Weak pacing or meaningless content hurts it.
+        
+        - `visual_diversity`: Does the video use **multiple camera angles, transitions, or visual styles**? A lack of variation makes it feel stale.
+
+        ---
+                                
+        ### 📌 Scoring Enforcement Guidelines
+
+        - Be **strict**: Low-effort content should fall well below 50  
+        - Be **realistic**: Reward polish, creativity, clarity, and emotional impact  
+        - Only videos with **clear intent and great execution** should reach 80+  
+        - Penalize poor hooks, bland visuals, unclear audio, or meaningless structure  
+        - Ensure your scores reflect meaningful differences between videos — **don't cluster everything around 60**
+        
+        ---
+        """)
+
+        if self.audio_analysis:
+            prompt_sections.append("Audio Analysis:\n" + json.dumps(self.audio_analysis, indent=2))
+        if self.frame_analysis:
+            prompt_sections.append("\nFrame Analysis:\n" + json.dumps(self.frame_analysis, indent=2))
+        if self.hook_analysis:
+            prompt_sections.append("\nHook Alignment Analysis:\n" + json.dumps(self.hook_analysis, indent=2))
+
+        matrices = self.extract_matrices()
+        prompt_sections.append("\nHere are extracted behavioral/performance matrices:\n" + json.dumps(matrices, indent=2))
+
+        prompt_sections.append(f"""
+        ### 📤 Output Format (JSON Only — No Comments or Explanations):
+        {{
+        "video_name": "{self.video_path.stem}",
+        "scores": {{
+            "hook": 0,
+            "visuals": 0,
+            "audio": 0,
+            "engagement": 0,
+            "visual_diversity": 0
+        }},
+        "matrices": {{
+            "tone": "",
+            "emotion": "",
+            "pace": "",
+            "facial_sync": ""
+        }},
+        "summary": "",
+        "suggestions": [
+            "Specific improvement 1",
+            "Specific improvement 2",
+            "Specific improvement 3",
+            ... more if required
+        ]
+        }}
+        """)
+        return "\n".join(prompt_sections)
+
+    def query_llm(self, prompt: str) -> dict:
+        try:
+            response = openai.chat.completions.create(
+                model='gpt-4o',
+                messages=[
+                    {"role": "system", "content": "You are a professional short-video quality evaluator."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.4,
+            )
+            reply = response.choices[0].message.content.strip()
+            cleaned = reply.replace('```json', '').replace('```', '')
+            result = json.loads(cleaned)
+            return result
+        except Exception as e:
+            self.logger.error(f"LLM generation failed: {e}")
+            return {
+                "scores": {
+                    "hook": 0,
+                    "visuals": 0,
+                    "audio": 0,
+                    "engagement": 0,
+                    "visual_diversity": 0
+                },
+                "matrices": self.extract_matrices(),
+                "summary": "Failed to generate report.",
+                "suggestions": ["Try again", "Check input files", "Verify OpenAI key"]
+            }
+    
+    def compute_virality_score(self, result):
+        weights = {
+            'hook': 0.18,
+            'visuals': 0.20,
+            'audio': 0.25,
+            'engagement': 0.27,
+            'visual_diversity': 0.10
+        }
+
+        sub_scores = result["scores"]
+        base_score = sum(sub_scores[key] * weights[key] for key in weights)
+
+        bonus = 0
+        matrices = result.get("matrices", {})
+
+        if matrices.get("emotion") in ["joy", "inspiration"]:
+            bonus += 6
+        if matrices.get("tone") in ["funny", "relatable"]:
+            bonus += 6
+        if matrices.get("facial_sync") in ["ok", "good"]:
+            bonus += 4
+
+        if sub_scores.get("hook", 0) <= 30:
+            bonus -= 6
+        if sub_scores.get("audio", 0) < 40:
+            bonus -= 5
+        if matrices.get("facial_sync") == "none":
+            bonus -= 5
+
+        final_score = max(0, min(100, int(base_score + bonus)))
+        return final_score
+
+    def generate(self) -> dict:
+        self.logger.info("Preparing prompt for LLM...")
+        prompt = self.prepare_prompt()
+
+        self.logger.info("Querying LLM for report generation...")
+        result = self.query_llm(prompt)
+        total_score = self.compute_virality_score(result)
+        final_output = {
+            "video_name": self.video_path.stem,
+            "total_score":  total_score,
+            **result  
+        }
+        self.logger.info("Saving final report...")
+        self.output_json.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.output_json, 'w', encoding='utf-8') as f:
+            json.dump(final_output, f, indent=2)
+
+        self.logger.info("Report successfully generated at %s", self.output_json)
+        return final_output

files/utils/logging.py

@@ -0,0 +1,19 @@
+import logging
+from pathlib import Path
+from config import LOG_DIR
+
+
+def get_logger(name='vc', log_file: str = 'latest.log', level='INFO'):
+    Path(LOG_DIR).mkdir(exist_ok=True)
+    log_path = LOG_DIR / log_file
+
+    logger = logging.getLogger(name)
+    logger.setLevel(level.upper())
+
+    if not logger.handlers:
+        handler = logging.FileHandler(log_path, encoding='utf-8')
+        formatter = logging.Formatter('%(asctime)s | %(levelname)-7s | %(name)s | %(message)s')
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    return logger

main.py

@@ -1,9 +1,9 @@
 from pathlib import Path
-from app.pipeline.scoring import VideoReport
-from app.pipeline.scene_detect import SceneDetector
-from app.pipeline.frame_extract import FrameExtractor
-from app.pipeline.audio_analysis import AudioAnalyzer
-from app.pipeline.frame_analysis import FrameAnalyzer, HookAnalyzer
+from files.pipeline.scoring import VideoReport
+from files.pipeline.scene_detect import SceneDetector
+from files.pipeline.frame_extract import FrameExtractor
+from files.pipeline.audio_analysis import AudioAnalyzer
+from files.pipeline.frame_analysis import FrameAnalyzer, HookAnalyzer
 
 
 def run_pipeline(video_path: str):

ui/streamlit_app.py

@@ -33,12 +33,12 @@ if str(ROOT) not in sys.path:
     sys.path.insert(0, str(ROOT))
 
 # For debugging path issues
-print("sys.path:", sys.path)
-print("ROOT:", ROOT)
+# print("sys.path:", sys.path)
+# print("ROOT:", ROOT)
 
 from config import make_path
-from app.pipeline.scene_detect import SceneDetector
-from app.pipeline.frame_extract import FrameExtractor
+from files.pipeline.scene_detect import SceneDetector
+from files.pipeline.frame_extract import FrameExtractor
 
 # -----------------------------
 # Storage layout
@@ -354,7 +354,7 @@ def _run_current_stage():
         elif stage == "frame analysis":
             push_status("Analyzing frames…")
             if st.session_state.openai_key and st.session_state.openai_key.strip():
-                from app.pipeline.frame_analysis import FrameAnalyzer
+                from files.pipeline.frame_analysis import FrameAnalyzer
                 try:
                     FrameAnalyzer(str(vp), openai_api_key=st.session_state.openai_key.strip()).analyze()
                 except Exception as api_error:
@@ -380,7 +380,7 @@ def _run_current_stage():
         elif stage == "audio analysis":
             push_status("Analyzing audio…")
             if st.session_state.gemini_key and st.session_state.gemini_key.strip():
-                from app.pipeline.audio_analysis import AudioAnalyzer
+                from files.pipeline.audio_analysis import AudioAnalyzer
                 try:
                     AudioAnalyzer(str(vp), gemini_api_key=st.session_state.gemini_key.strip()).analyze()
                 except (ValueError, Exception) as api_error:
@@ -406,7 +406,7 @@ def _run_current_stage():
         elif stage == "hook analysis":
             push_status("Evaluating hook…")
             if st.session_state.gemini_key and st.session_state.gemini_key.strip():
-                from app.pipeline.frame_analysis import HookAnalyzer
+                from files.pipeline.frame_analysis import HookAnalyzer
                 try:
                     HookAnalyzer(str(vp), gemini_api_key=st.session_state.gemini_key.strip()).analyze()
                 except (ValueError, Exception) as api_error:
@@ -432,7 +432,7 @@ def _run_current_stage():
         elif stage == "report":
             push_status("Generating final report…")
             if st.session_state.openai_key and st.session_state.openai_key.strip():
-                from app.pipeline.scoring import VideoReport
+                from files.pipeline.scoring import VideoReport
                 try:
                     VideoReport(str(vp), openai_api_key=st.session_state.openai_key.strip()).generate()
                 except Exception as api_error: