Upload 115 files

.gitattributes

@@ -35,3 +35,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 fonts/TikTok-Bold.ttf filter=lfs diff=lfs merge=lfs -text
 gradio_demo.png filter=lfs diff=lfs merge=lfs -text
+assets/edu_note.wav filter=lfs diff=lfs merge=lfs -text
+assets/fun_fact.wav filter=lfs diff=lfs merge=lfs -text
+assets/thanks.wav filter=lfs diff=lfs merge=lfs -text

publisher/ai/gemini_client.py

@@ -53,11 +53,20 @@ def _pick_model():
 def get_model():
     """
     Public entrypoint used by publisher_ai.
-    Returns active Gemini model name.
+    Returns an initialized Gemini model.
     """
-    model = _pick_model()
-    logger.info(f"[Gemini] Selected model: {model}")
-    return model
+    try:
+        import google.generativeai as genai
+    except ImportError as exc:
+        raise RuntimeError("google-generativeai is required for Gemini features") from exc
+
+    api_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+    if api_key:
+        genai.configure(api_key=api_key)
+
+    model_name = _pick_model()
+    logger.info(f"[Gemini] Selected model: {model_name}")
+    return genai.GenerativeModel(model_name)
 
 
 def safe_generate(prompt: str, client_callable):
@@ -80,4 +89,4 @@ def safe_generate(prompt: str, client_callable):
             logger.warning(f"[Gemini FAIL] {model}: {str(e)}")
             time.sleep(0.5)
 
-    raise RuntimeError(f"All Gemini models failed: {last_error}")
+    raise RuntimeError(f"All Gemini models failed: {last_error}")

publisher/metadata_engine.py

@@ -7,6 +7,7 @@ def generate_metadata(video_path: str):
 
     prompt = f"""
     Generate viral short-form video metadata.
+    Source: {video_path}
 
     Return JSON:
     title
@@ -21,4 +22,4 @@ def generate_metadata(video_path: str):
 
     return {
         "metadata": text
-    }
+    }

publisher/publisher.py

@@ -1,9 +1,10 @@
+import asyncio
 import requests
 
-from .metadata import generate_metadata
+from .metadata_engine import generate_metadata
 from .hashtags import generate_hashtags
 from .thumbnail import generate_thumbnail
-from .scheduler import schedule_post
+from .scheduler_engine import schedule_post
 from .router import publish_all
 
 
@@ -17,13 +18,13 @@ async def run_publisher(payload: dict):
     )
 
     # 1. Metadata
-    metadata = await generate_metadata(source)
+    metadata = await asyncio.to_thread(generate_metadata, source)
 
     # 2. Hashtags
-    hashtags = await generate_hashtags(metadata)
+    hashtags = await asyncio.to_thread(generate_hashtags, metadata)
 
     # 3. Thumbnail
-    thumbnail = await generate_thumbnail(source)
+    thumbnail = await asyncio.to_thread(generate_thumbnail, source)
 
     # 4. Schedule
     schedule_time = schedule_post(payload)
@@ -47,6 +48,6 @@ async def run_publisher(payload: dict):
     }
 
     if webhook:
-        requests.post(webhook, json=response)
+        await asyncio.to_thread(requests.post, webhook, json=response, timeout=10)
 
-    return response
+    return response

publisher/publisher_ai.py

@@ -35,12 +35,12 @@ async def process_job(job: Dict[str, Any]) -> Dict[str, Any]:
     job_type = job.get("type")
     payload = job.get("payload", {})
 
-    if job_type == "publish":
-        if not dispatch_publish:
-            raise RuntimeError("dispatch_publish not available")
+    if job_type in {"publish", "auto-publish"} and not dispatch_publish:
+        raise RuntimeError("dispatch_publish not available")
 
+    if job_type == "publish":
         return await dispatch_publish(
-            video_path=payload.get("video_path"),
+            video_path=payload.get("video_path") or payload.get("source"),
             payload=payload
         )
 
@@ -102,11 +102,13 @@ async def autonomous_loop(seed_video_path: Optional[str] = None):
 
             # 3. Process job
             result = await process_job(job)
+            job["status"] = "completed"
+            job["result"] = result
 
             logger.info(f"[V10] Job completed: {job.get('id')}")
 
             # 4. Optional webhook callback
-            webhook = job.get("webhook")
+            webhook = job.get("webhook") or payload.get("webhook")
             if webhook:
                 asyncio.create_task(_send_webhook(webhook, result))
 
@@ -170,27 +172,13 @@ async def _send_webhook(url: str, data: dict):
 # PUBLIC ENTRYPOINT (REQUIRED BY MAIN APP)
 # =====================================================
 
-import asyncio
-
-
 async def start_autonomous_brain():
     """
     Unified startup entry for Autonomous Publisher.
     Safe background loop.
     """
 
-    while True:
-        try:
-            # call your existing brain runner here
-            await asyncio.to_thread(run_autonomous_engine)
-
-        except Exception as e:
-            print("Autonomous brain error:", e)
-
-        # prevent CPU burn
-        await asyncio.sleep(30)
-
-        import asyncio
+    await autonomous_loop()
 
 
 async def start_brain():
@@ -198,16 +186,4 @@ async def start_brain():
     V11 Standard Publisher Entry Point
     """
 
-    while True:
-        try:
-            # 🔁 Replace this with your real engine function
-            # Example options:
-            # await asyncio.to_thread(run_autonomous_engine)
-            # await asyncio.to_thread(autonomous_loop)
-            # await asyncio.to_thread(run_brain)
-
-            await asyncio.sleep(10)
-
-        except Exception as e:
-            print("[Publisher Brain Error]", e)
-            await asyncio.sleep(10)
+    await autonomous_loop()

publisher/router.py

@@ -1,28 +1,75 @@
-from  publisher.platforms.tiktok import TikTokPublisher
-from  publisher.platforms.reels import ReelsPublisher
-from  publisher.platforms.shorts import ShortsPublisher
-from  publisher.platforms.facebook import FacebookPublisher
+from publisher.platforms.facebook import publish_facebook
+from publisher.platforms.reels import publish_reels
+from publisher.platforms.shorts import publish_shorts
+from publisher.platforms.tiktok import publish_tiktok
 
 
 PUBLISHERS = {
-    "tiktok": TikTokPublisher(),
-    "reels": ReelsPublisher(),
-    "shorts": ShortsPublisher(),
-    "facebook": FacebookPublisher(),
+    "tiktok": publish_tiktok,
+    "reels": publish_reels,
+    "shorts": publish_shorts,
+    "facebook": publish_facebook,
 }
 
 
-async def publish(payload):
-
+async def publish_all(
+    source,
+    platforms,
+    metadata=None,
+    hashtags=None,
+    thumbnail=None,
+    schedule_time=None,
+):
     results = {}
+    metadata = metadata or {}
+    hashtags = hashtags or {}
+    caption = metadata.get("metadata") if isinstance(metadata, dict) else str(metadata)
+    tag_value = hashtags.get("hashtags", hashtags) if isinstance(hashtags, dict) else hashtags
+    if isinstance(tag_value, str):
+        tag_value = [tag.strip() for tag in tag_value.split(",") if tag.strip()]
 
-    for platform in payload.platforms:
-
+    for platform in platforms:
         publisher = PUBLISHERS.get(platform)
-
         if not publisher:
+            results[platform] = {"status": "skipped", "error": "Unsupported platform"}
             continue
 
-        results[platform] = await publisher.safe_publish(payload)
+        platform_payload = {
+            "video_path": source,
+            "caption": caption or "",
+            "hashtags": tag_value or [],
+            "thumbnail": thumbnail,
+            "schedule_time": schedule_time,
+        }
+        try:
+            results[platform] = await publisher(platform_payload)
+        except Exception as exc:
+            results[platform] = {"status": "failed", "error": str(exc)}
+
+    return results
+
+
+async def publish(payload):
+    if isinstance(payload, dict):
+        source = payload.get("source") or payload.get("video_path")
+        platforms = payload.get("platforms", [])
+        metadata = payload.get("metadata")
+        hashtags = payload.get("hashtags")
+        thumbnail = payload.get("thumbnail")
+        schedule_time = payload.get("schedule_time")
+    else:
+        source = getattr(payload, "source", None) or getattr(payload, "video_path", None)
+        platforms = getattr(payload, "platforms", [])
+        metadata = getattr(payload, "metadata", None)
+        hashtags = getattr(payload, "hashtags", None)
+        thumbnail = getattr(payload, "thumbnail", None)
+        schedule_time = getattr(payload, "schedule_time", None)
 
-    return results
+    return await publish_all(
+        source=source,
+        platforms=platforms,
+        metadata=metadata,
+        hashtags=hashtags,
+        thumbnail=thumbnail,
+        schedule_time=schedule_time,
+    )

publisher/scheduler_engine.py

@@ -1,6 +1,6 @@
 import asyncio
 import logging
-from datetime import datetime, timedelta
+from datetime import datetime, timezone
 
 logger = logging.getLogger("scheduler-engine")
 
@@ -48,6 +48,7 @@ def schedule_post(payload: dict):
 
     job = {
         "id": f"job_{len(_tasks)+1}",
+        "type": payload.get("type", "publish"),
         "payload": payload,
         "status": "queued",
         "created_at": datetime.utcnow().isoformat()
@@ -60,6 +61,35 @@ def schedule_post(payload: dict):
     return job
 
 
+def _publish_time(payload: dict) -> datetime | None:
+    value = payload.get("publish_at")
+    if not value:
+        return None
+
+    publish_time = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+    if publish_time.tzinfo is None:
+        publish_time = publish_time.replace(tzinfo=timezone.utc)
+    return publish_time
+
+
+async def get_next_job():
+    """Return the next due job and claim it for a publisher worker."""
+    now = datetime.now(timezone.utc)
+
+    for job in _tasks:
+        if job["status"] not in {"queued", "ready"}:
+            continue
+
+        publish_time = _publish_time(job["payload"])
+        if publish_time and now < publish_time:
+            continue
+
+        job["status"] = "processing"
+        return job
+
+    return None
+
+
 # =========================
 # WORKER LOOP
 # =========================
@@ -73,20 +103,15 @@ async def _worker_loop():
 
     while True:
         try:
-            now = datetime.utcnow()
+            now = datetime.now(timezone.utc)
 
             for job in _tasks:
                 if job["status"] != "queued":
                     continue
 
-                publish_time = job["payload"].get("publish_at")
-
-                if not publish_time:
-                    continue
-
-                publish_time = datetime.fromisoformat(publish_time)
+                publish_time = _publish_time(job["payload"])
 
-                if now >= publish_time:
+                if publish_time is None or now >= publish_time:
                     logger.info(f"[Scheduler] Executing {job['id']}")
 
                     # mark as done (actual publish handled elsewhere)
@@ -106,4 +131,4 @@ def start_scheduler_loop():
     """
     Optional explicit background runner.
     """
-    asyncio.create_task(_worker_loop())
+    asyncio.create_task(_worker_loop())

utils/batch_queue.py

@@ -1,11 +1,10 @@
 import threading
 from queue import Queue
 import uuid
-import time
 
 from .job_queue import jobs, update, notify_webhook
 from .transcription import transcribe_video
-from .render import render_video
+from .clipper import create_clip
 from .highlights import detect_highlights
 
 
@@ -59,9 +58,10 @@ def worker():
                 start = segment[0]["start"]
                 end = segment[-1]["end"]
 
-                clip_path = render_video(job["video"], words)
+                clip_path = create_clip(job["video"], start, end, i)
 
-                outputs.append(clip_path)
+                if clip_path:
+                    outputs.append(clip_path)
 
                 update(job_id, progress=50 + int((i+1)/len(highlights)*40))
 
@@ -87,4 +87,4 @@ def worker():
 def start_batch_worker():
 
     t = threading.Thread(target=worker, daemon=True)
-    t.start()
+    t.start()

utils/clipper.py

@@ -1,6 +1,6 @@
 from moviepy.editor import VideoFileClip
-import os
 import logging
+from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
@@ -40,6 +40,21 @@ def normalize_segments(segments):
                 })
             continue
 
+        # grouped word segments from detect_highlights()
+        if (
+            isinstance(s, (list, tuple))
+            and s
+            and isinstance(s[0], dict)
+            and isinstance(s[-1], dict)
+            and "start" in s[0]
+            and "end" in s[-1]
+        ):
+            normalized.append({
+                "start": float(s[0]["start"]),
+                "end": float(s[-1]["end"]),
+            })
+            continue
+
         # list/tuple format
         if isinstance(s, (list, tuple)) and len(s) >= 2:
             try:
@@ -72,10 +87,8 @@ def create_clip(video_path, start, end, index):
 
         clip = VideoFileClip(video_path).subclip(start, end)
 
-        output = video_path.replace(
-            ".mp4",
-            f"_clip_{index}.mp4"
-        )
+        source = Path(video_path)
+        output = str(source.with_name(f"{source.stem}_clip_{index}.mp4"))
 
         clip.write_videofile(
             output,
@@ -127,4 +140,4 @@ def create_clips(video_path, segments):
             logger.error(f"Segment {i} failed: {str(e)}")
             continue
 
-    return outputs
+    return outputs

utils/job_queue.py

@@ -3,6 +3,8 @@ import uuid
 from queue import Queue
 import traceback
 import time
+import json
+import urllib.request
 
 from .logger import logger
 from .validators import validate_video
@@ -77,6 +79,22 @@ def update(job_id, **kwargs):
         jobs[job_id].update(kwargs)
 
 
+def notify_webhook(job_id):
+    job = jobs.get(job_id)
+    if not job or not job.get("webhook"):
+        return
+
+    request = urllib.request.Request(
+        job["webhook"],
+        data=json.dumps(job).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+    )
+    try:
+        urllib.request.urlopen(request, timeout=10).close()
+    except Exception as exc:
+        logger.warning(f"Webhook delivery failed for {job_id}: {exc}")
+
+
 # =====================================================
 # V7 AUTONOMOUS DIRECTOR WORKER
 # =====================================================
@@ -191,4 +209,4 @@ def start_worker():
     t = threading.Thread(target=worker, daemon=True)
     t.start()
 
-    logger.info("[V7] Worker initialized")
+    logger.info("[V7] Worker initialized")