fix(renderer): valid Scene code + robust CLI call

backend/renderer.py

@@ -1,117 +1,136 @@
 import os
-import subprocess
 import tempfile
+import subprocess
 from pathlib import Path
+from typing import Tuple
+from fastapi import UploadFile
+
+# Manim kalite kısayolları
+_QUALITY = {"l": "l", "m": "m", "h": "h", "u": "u"}
+
+def _save_upload(tmpdir: Path, file: UploadFile) -> Path:
+    ext = Path(file.filename or "file").suffix.lower()
+    out = tmpdir / f"input{ext}"
+    with out.open("wb") as f:
+        f.write(file.file.read())
+    return out
 
+def _gen_scene_py(
+    path: Path, anim: str, duration: float, bg_color: str
+) -> Path:
+    """
+    logo_scene.py dosyasını üretir ve yolunu döner.
+    'draw' yalnızca SVG kabul eder.
+    """
+    is_svg = path.suffix.lower() == ".svg"
+    safe_path = repr(str(path))  # path'i güvenli biçimde göm
 
-def _scene_code(input_path: str, animation: str, duration: float, bg_color: str) -> str:
-    is_svg = str(input_path).lower().endswith(".svg")
-    return f"""
-from manim import *
-from manim import rate_functions as rf
+    if anim == "draw" and not is_svg:
+        raise ValueError("Draw animasyonu yalnızca SVG ile çalışır.")
+
+    # Ortak başlangıç
+    head = f"""from manim import *
 
 class LogoScene(Scene):
     def construct(self):
-        config.background_color = "{bg_color}"
-        path = r{input_path!r}
-        is_svg = {str(is_svg)}
-
-        if is_svg:
-            try:
-                mobj = SVGMobject(path)
-                mobj.set_height(5).move_to(ORIGIN)
-
-                if {animation!r} == "draw":
-                    # Fill'leri kapat, stroke'u görünür yap
-                    for sm in mobj.family_members_with_points():
-                        if hasattr(sm, "set_fill"):
-                            sm.set_fill(opacity=0)
-                        if hasattr(sm, "set_stroke"):
-                            sm.set_stroke((sm.stroke_color or WHITE),
-                                          width=(sm.stroke_width or 2),
-                                          opacity=1.0)
-
-                    parts = [sm for sm in mobj.family_members_with_points() if sm.has_points()]
-                    if len(parts) == 0:
-                        self.add(mobj)
-                        self.play(FadeIn(mobj, run_time={duration}))
-                        self.wait(0.2)
-                        return
-
-                    self.play(
-                        LaggedStart(*[Create(p) for p in parts], lag_ratio=0.05),
-                        run_time=max(0.6, {duration}*0.85)
-                    )
-                    # fill'leri geri getir
-                    self.play(
-                        *[p.animate.set_fill(opacity=1.0) for p in parts if hasattr(p, "set_fill")],
-                        run_time=max(0.2, {duration}*0.15)
-                    )
-                    self.wait(0.2)
-                    return
-            except Exception:
-                is_svg = False
-
-        # SVG değilse (veya draw değilse) fallback
-        if not is_svg:
-            mobj = ImageMobject(path).set_height(5).move_to(ORIGIN)
-
-        if {animation!r} == "spin":
-            self.play(FadeIn(mobj, run_time=max(0.2, {duration}*0.25), scale=0.8))
-            self.play(Rotate(mobj, angle=TAU, run_time=max(0.4, {duration}*0.75)))
-            self.wait(0.2)
-        elif {animation!r} == "bounce":
-            # küçük başlat → orijinal boyuta "zıplayarak" gel
-            mobj.scale(0.01)
-            self.add(mobj)
-            self.play(
-                mobj.animate.scale(100),
-                run_time=max(0.4, {duration}*0.6),
-                rate_func=rf.ease_out_back
-            )
-            self.play(
-                mobj.animate.scale(0.95),
-                run_time=max(0.2, {duration}*0.2),
-                rate_func=rf.ease_out_sine
-            )
-            self.wait(0.2)
+        self.camera.background_color = "{bg_color}"
+        """
+
+    if anim == "draw":
+        body = f"""
+        m = SVGMobject({safe_path}).set_height(5).move_to(ORIGIN)
+        self.play(Create(m), run_time={float(duration)}, rate_func=linear)
+        self.wait(0.2)
+        """
+    else:
+        # Raster ve SVG ikisi de desteklensin
+        loader = (
+            f'SVGMobject({safe_path}).set_height(5)'
+            if is_svg else
+            f'ImageMobject({safe_path}).scale(0.9)'
+        )
+        body_start = f"""m = {loader}
+        m.move_to(ORIGIN)
+        """
+
+        if anim == "fade":
+            body_anim = f"""
+        self.play(FadeIn(m), run_time=max(0.3, {float(duration)}*0.5))
+        self.wait(0.1)
+        self.play(FadeOut(m), run_time=max(0.2, {float(duration)}*0.3))
+        """
+        elif anim == "spin":
+            body_anim = f"""
+        self.play(FadeIn(m, scale=0.8), run_time=max(0.2, {float(duration)}*0.2))
+        self.play(Rotate(m, angle=2*PI), rate_func=linear, run_time=max(0.4, {float(duration)}*0.6))
+        self.play(FadeOut(m), run_time=max(0.1, {float(duration)}*0.2))
+        """
+        elif anim == "bounce":
+            body_anim = f"""
+        from manim import UP, DOWN, there_and_back
+        self.play(FadeIn(m, shift=UP*3), run_time=max(0.2, {float(duration)}*0.25))
+        self.play(m.animate.shift(DOWN*3).scale(1.02), rate_func=there_and_back, run_time=max(0.4, {float(duration)}*0.55))
+        self.play(FadeOut(m), run_time=max(0.15, {float(duration)}*0.2))
+        """
         else:
-            # fade
-            self.play(FadeIn(mobj, run_time={duration}))
-            self.wait(0.3)
-"""
-
-
-def render_logo(input_path: str, output_path: str, animation: str, duration: float, bg_color: str, quality: str = "m"):
-    qflag = {"l": "-ql", "m": "-qm", "h": "-qh", "u": "-qu"}.get(quality.lower(), "-qm")
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        scene_file = Path(tmpdir) / "logo_scene.py"
-        scene_file.write_text(_scene_code(str(input_path), animation, duration, bg_color), encoding="utf-8")
-
-        cmd = [
-            "manim",
-            qflag,
-            str(scene_file),
-            "LogoScene",
-            "-o", "logo_render.mp4",
-            "--format", "mp4",
-            "--disable_caching",
-            "--media_dir", tmpdir,
-        ]
-        try:
-            subprocess.run(cmd, check=True, capture_output=True, text=True)
-        except subprocess.CalledProcessError as e:
-            raise RuntimeError(f"Manim failed: {e.stderr or e.stdout}")
-
-        vid = None
-        for p in Path(tmpdir).rglob("*.mp4"):
-            if p.name.endswith(".mp4"):
-                vid = p
-                break
-        if not vid:
-            raise RuntimeError("Render output not found.")
-
-        os.makedirs(os.path.dirname(output_path), exist_ok=True)
-        with open(vid, "rb") as src, open(output_path, "wb") as dst:
-            dst.write(src.read())
+            raise ValueError("Geçersiz animasyon tipi.")
+
+        body = body_start + body_anim
+
+    code = head + body + "\n"
+    scene_py = path.parent / "logo_scene.py"
+    scene_py.write_text(code, encoding="utf-8")
+    return scene_py
+
+def _run_manim(scene_py: Path, quality: str) -> Path:
+    """
+    Manim'i çalıştırır ve üretilen mp4 yolunu döndürür.
+    """
+    q = _QUALITY.get(quality, "m")
+    tmpdir = scene_py.parent
+    out_name = "out.mp4"
+
+    cmd = [
+        "manim",
+        "-q", q,
+        str(scene_py),
+        "LogoScene",
+        "-o", out_name,
+        "--format=mp4",
+        "--media_dir", str(tmpdir),
+    ]
+
+    proc = subprocess.run(
+        cmd, cwd=tmpdir, capture_output=True, text=True
+    )
+    if proc.returncode != 0:
+        raise RuntimeError(f"Manim failed: {proc.stderr or proc.stdout}")
+
+    # media_dir altında mp4'ü bul
+    for root, _, files in os.walk(tmpdir):
+        if out_name in files:
+            return Path(root) / out_name
+
+    raise RuntimeError("Çıktı mp4 bulunamadı.")
+
+async def render_logo(
+    file: UploadFile,
+    animation: str,
+    duration: float,
+    bg_color: str,
+    quality: str,
+) -> Path:
+    """
+    FastAPI endpoint'inin kullandığı ana fonksiyon.
+    """
+    with tempfile.TemporaryDirectory() as tdir:
+        tdir = Path(tdir)
+        input_path = _save_upload(tdir, file)
+        scene_py = _gen_scene_py(input_path, animation, duration, bg_color)
+        mp4 = _run_manim(scene_py, quality)
+        # mp4’ü kalıcı path’e taşı (tmp kapanınca silinmesin diye)
+        final_dir = Path("/tmp/manim_out")
+        final_dir.mkdir(parents=True, exist_ok=True)
+        final_path = final_dir / mp4.name
+        final_path.write_bytes(mp4.read_bytes())
+        return final_path