Upload 2 files

generator_function/video_hashid_function.py

@@ -0,0 +1,153 @@
+from pathlib import Path
+from typing import Optional
+import hashlib, base64, binascii, math, subprocess, shutil, os, logging, uuid, tempfile
+from dotenv import load_dotenv
+from imageio_ffmpeg import get_ffmpeg_exe
+import boto3
+
+load_dotenv()
+logger = logging.getLogger(__name__)
+
+# ---------- HASH UTILS ----------
+def _sha256(path: Path, chunk: int = 1 << 20) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for b in iter(lambda: f.read(chunk), b""):
+            h.update(b)
+    return h.hexdigest()
+
+def _hashid_short(sha256_hex: str, length: int = 12) -> str:
+    b = binascii.unhexlify(sha256_hex)
+    return base64.urlsafe_b64encode(b).decode().rstrip("=")[:length]
+
+# ---------- FFMPEG ----------
+def _ffmpeg_bin() -> str:
+    try:
+        return get_ffmpeg_exe()
+    except Exception:
+        p = os.environ.get("FFMPEG_BIN") or shutil.which("ffmpeg")
+        if not p:
+            raise FileNotFoundError("ffmpeg not found. Install it or set FFMPEG_BIN")
+        return p
+
+FFMPEG = _ffmpeg_bin()
+
+def _run_ffmpeg(cmd: list[str]) -> None:
+    cmd = cmd[:]
+    cmd[0] = FFMPEG
+    proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if proc.returncode != 0:
+        raise RuntimeError(proc.stderr.decode(errors="ignore") or "ffmpeg failed")
+
+# ---------- THUMBNAIL ----------
+def extract_thumbnail(video_path: str, time_position: str = "00:00:01") -> str:
+    """
+    Extracts a thumbnail (JPEG) from the video and returns it as a base64 string.
+    Default frame at 1 second.
+    """
+    tmp_thumb = Path(tempfile.gettempdir()) / f"{Path(video_path).stem}_thumb.jpg"
+    cmd = [
+        "ffmpeg", "-nostdin", "-y",
+        "-ss", time_position,
+        "-i", video_path,
+        "-frames:v", "1",
+        "-q:v", "2",
+        str(tmp_thumb),
+    ]
+    _run_ffmpeg(cmd)
+
+    with open(tmp_thumb, "rb") as f:
+        encoded = base64.b64encode(f.read()).decode("utf-8")
+    return encoded
+
+# ---------- AUGMENT VIDEO ----------
+def augment_video_random(
+    *,
+    input_path: str,
+    output_path: Optional[str] = None,
+    crf: int = 20,
+    preset: str = "medium",
+) -> str:
+    import random
+    k_b, k_c, k_h, k_s = [random.randint(-5, 5) for _ in range(4)]
+    brightness = max(-1.0, min(1.0, k_b * 0.05))
+    contrast = max(0.0, min(2.0, 1.0 + k_c * 0.05))
+    hue_rad = math.radians(k_h * 5.0)
+    sat_scale = max(0.0, 1.0 + k_s * 0.05)
+
+    vf = f"hue=h={hue_rad:.6f}:s={sat_scale:.4f},eq=contrast={contrast:.4f}:brightness={brightness:.4f}"
+
+    inp = Path(input_path)
+    out = Path(output_path) / f"{inp.stem}_augmented.mp4" if output_path else inp.with_name(f"{inp.stem}_augmented.mp4")
+
+    cmd = [
+        "ffmpeg", "-nostdin", "-y",
+        "-i", str(inp),
+        "-map", "0:v:0", "-map", "0:a?",
+        "-vf", vf,
+        "-c:v", "libx264", "-preset", preset, "-crf", str(crf),
+        "-pix_fmt", "yuv420p",
+        "-c:a", "copy",
+        "-movflags", "+faststart",
+        str(out),
+    ]
+    _run_ffmpeg(cmd)
+    return str(out)
+
+# ---------- VIDEO UPLOAD TO R2 ----------
+def upload_video_to_r2(video_bytes: bytes, file_name: str) -> str:
+    s3 = boto3.client(
+        "s3",
+        endpoint_url=os.getenv("R2_ENDPOINT"),
+        aws_access_key_id=os.getenv("R2_ACCESS_KEY"),
+        aws_secret_access_key=os.getenv("R2_SECRET_KEY"),
+        region_name="auto",
+    )
+
+    bucket = os.getenv("R2_BUCKET_NAME")
+    key = f"videos/{uuid.uuid4()}_{file_name}"
+
+    s3.put_object(Bucket=bucket, Key=key, Body=video_bytes, ContentType="video/mp4")
+
+    return f"{os.getenv('NEW_BASE').rstrip('/')}/{key}"
+
+# ---------- PROCESS + UPLOAD ----------
+def process_video_with_hash_info(input_path: str, output_path: Optional[str] = None) -> dict:
+    in_sha = _sha256(Path(input_path))
+    in_id = _hashid_short(in_sha)
+
+    # Augment and get output
+    out_path = augment_video_random(input_path=input_path, output_path=output_path)
+
+    # output hashid
+    out_sha = _sha256(Path(out_path))
+    out_id = _hashid_short(out_sha)
+
+    # copy file to safe tmp path
+    safe_tmp = Path(tempfile.gettempdir()) / Path(out_path).name
+    shutil.copy(out_path, safe_tmp)
+
+    # thumbnail
+    try:
+        thumbnail_b64 = extract_thumbnail(str(safe_tmp))
+    except Exception as e:
+        logger.error(f"Thumbnail extraction failed: {e}")
+        thumbnail_b64 = ""
+
+
+    try:
+        with open(safe_tmp, "rb") as f:
+            video_bytes = f.read()
+        r2_url = upload_video_to_r2(video_bytes, Path(safe_tmp).name)
+    except Exception as e:
+        logger.error(f"Upload to R2 failed: {e}")
+        r2_url = None
+
+    return {
+        "input_hashid": in_id,
+        "output_name": Path(safe_tmp).name,
+        "output_path": str(safe_tmp),
+        "output_hashid": out_id,
+        "output_r2_url": r2_url,
+        "thumbnail": thumbnail_b64,
+    }

generator_function/video_text_generator.py

@@ -0,0 +1,54 @@
+import os, uuid, subprocess, boto3, replicate
+from typing import Dict, Any
+from dotenv import load_dotenv
+# from helpers_function.helpers import upload_to_r2
+
+load_dotenv()
+
+replicate_client = replicate.Client(api_token=os.getenv("REPLICATE_API_KEY"))
+
+def video_to_audio(video_path: str) -> str:
+    """Extract audio from video using ffmpeg and return audio filename."""
+    audio_filename = f"{uuid.uuid4()}.mp3"
+    command = [
+        "ffmpeg", "-hide_banner", "-loglevel", "error",
+        "-i", video_path, "-vn", "-acodec", "libmp3lame", "-y", audio_filename
+    ]
+    subprocess.run(command, check=True)
+    return audio_filename
+
+def extract_text_from_video(video_path: str, max_duration: int = 60) -> Dict[str, Any]:
+    """
+    Convert video speech to text using Replicate seamless model.
+    Steps:
+    1. Extract audio from video.
+    2. Upload audio to R2.
+    3. Run Replicate model.
+    """
+
+    audio_file = video_to_audio(video_path)
+
+
+    # audio_url = upload_to_r2(audio_file, f"audio/{os.path.basename(audio_file)}")
+
+    try:
+        with open(audio_file, "rb") as f:
+            # Call Replicate model
+            result = replicate_client.run(
+                "cjwbw/seamless_communication:668a4fec05a887143e5fe8d45df25ec4c794dd43169b9a11562309b2d45873b0",
+                input={
+                    "task_name": "S2ST (Speech to Speech translation)",
+                    "input_audio": f,
+                    "input_text_language": "None",
+                    "max_input_audio_length": max_duration,
+                    "target_language_text_only": "English",
+                    "target_language_with_speech": "English",
+                },
+            )
+    finally:
+        try:
+            os.remove(audio_file)
+        except Exception:
+            pass
+
+    return result if result else {"error": "No output"}