ytml-toolkit 0.1.0__tar.gz

ytml_toolkit-0.1.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.2
+Name: ytml-toolkit
+Version: 0.1.0
+Requires-Python: >=3.7
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: websockets
+Requires-Dist: boto3
+Requires-Dist: gtts
+Requires-Dist: pydub
+Requires-Dist: moviepy
+Requires-Dist: imageio
+Requires-Dist: imageio-ffmpeg
+Requires-Dist: playwright
+Requires-Dist: numpy
+Requires-Dist: requests
+Requires-Dist: python-dotenv
+Requires-Dist: beautifulsoup4
+Requires-Dist: lxml
+Requires-Dist: tqdm
+Requires-Dist: pyttsx3
+Requires-Dist: starlette
+Requires-Dist: colorama
+Dynamic: requires-dist
+Dynamic: requires-python

ytml_toolkit-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ytml_toolkit-0.1.0/setup.py

@@ -0,0 +1,34 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="ytml-toolkit",
+    version="0.1.0",
+    packages=find_packages(),
+    entry_points={
+        "console_scripts": [
+            "ytml=ytml.cli:main",  # This makes `ytml` a command
+        ],
+    },
+    install_requires=[
+        "fastapi",
+        "uvicorn",
+        "websockets",
+        "boto3",
+        "gtts",
+        "pydub",  # Used for audio processing
+        "moviepy",  # Used for video processing
+        "imageio",  # Required for image/video handling
+        "imageio-ffmpeg",  # Supports video encoding/decoding
+        "playwright",  # Needed for rendering animations
+        "numpy",  # If used in image/video processing
+        "requests",  # Required for API requests (e.g., ElevenLabs)
+        "python-dotenv",  # If you're using `.env` files for config
+        "beautifulsoup4",  # If used for HTML parsing
+        "lxml",  # If parsing XML or HTML
+        "tqdm",  # If you're showing progress bars
+        "pyttsx3",  # If using local TTS
+        "starlette",  # Dependency of FastAPI,
+        "colorama"
+    ],
+    python_requires=">=3.7",
+)

ytml_toolkit-0.1.0/ytml/cli.py

@@ -0,0 +1,75 @@
+import argparse
+import os
+import sys
+from ytml.vocalforge.xi_labs_vocal_forge import ElevenLabsVocalForge
+from ytml.vocalforge.gtts_vocal_forge import gTTSVocalForge
+from ytml.conductor.conductor import Conductor
+from ytml.utils.config import get_config_from_file
+from tqdm import tqdm  
+from colorama import Fore, Style 
+
+VERSION = "0.1.0" 
+
+def check_elevenlabs_key():
+    """Check if ELEVEN_LABS_API_KEY is set, warn if missing."""
+    if not os.getenv("ELEVEN_LABS_API_KEY"):
+        print(Fore.YELLOW + "[WARNING] ELEVEN_LABS_API_KEY is not set. "
+              "Use --use-gtts or define the API key for Eleven Labs." + Style.RESET_ALL)
+        return False
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser(description="YTML CLI - Video Generation Compiler")
+    parser.add_argument("-i", "--input", help="Path to the YTML input file.")
+    parser.add_argument("-o", "--output", default="output_video.mp4", help="Output video file.")
+    parser.add_argument("--use-gtts", action="store_true", help="Use gTTS VocalForge instead of Eleven Labs.")
+    parser.add_argument("--skip", nargs="*", choices=["parse", "voiceover", "render", "sync", "compose"], help="Steps to skip.")
+    parser.add_argument("--resume", help="Resume a job using the provided UUID.")
+    parser.add_argument("--job", help="Job ID of voiceovers to mix. Requires --skip voiceover.")
+    parser.add_argument("--preview", action="store_true", help="Preview HTML only.")
+    parser.add_argument("--version", action="store_true", help="Show CLI version.")
+
+    args = parser.parse_args()
+
+    # ✅ Handle version and help
+    if args.version:
+        print(Fore.CYAN + f"YTML CLI Version: {VERSION}" + Style.RESET_ALL)
+        sys.exit(0)
+
+    # ✅ Check if Eleven Labs API Key is missing
+    if not args.use_gtts:
+        if not check_elevenlabs_key():
+            return
+
+    config = get_config_from_file(args.input)
+
+    if args.preview:
+        conductor = Conductor(None, args.output, config)
+        conductor.previewHTML(args.input)
+        return
+
+    if args.resume:
+        job_dir = f"tmp/{args.resume}"
+        if not os.path.exists(job_dir):
+            print(Fore.RED + f"[ERROR] No job found with UUID {args.resume}." + Style.RESET_ALL)
+            return
+
+        print(Fore.BLUE + f"[INFO] Resuming job with UUID {args.resume}..." + Style.RESET_ALL)
+        conductor = Conductor(None, args.output, job_id=args.resume)
+        status = conductor.get_job_status()
+
+        skip_steps = [stage for stage in ["parse", "voiceover", "render", "sync"] if status.get(f"{stage}.json")]
+        conductor.run_workflow(f"{job_dir}/parsed.json", skip_steps)
+        return
+
+    if not os.path.exists(args.input):
+        print(Fore.RED + f"[ERROR] Input file '{args.input}' not found." + Style.RESET_ALL)
+        return
+    vocal_forge = gTTSVocalForge() if args.use_gtts or config.ENABLE_AI_VOICE == False else ElevenLabsVocalForge(config.AI_VOICE_ID)
+    conductor = Conductor(vocal_forge, args.output, config=config)
+    conductor.run_workflow(args.input, skip_steps=args.skip or [], job=args.job)
+
+
+if __name__ == "__main__":
+    main()

ytml_toolkit-0.1.0/ytml/interpretron/parser.py

@@ -0,0 +1,192 @@
+import re
+import unicodedata
+import xml.etree.ElementTree as ET
+import json
+from ytml.utils.utils import parse_boolean, parse_duration
+
+
+class YTMLParser:
+    def __init__(self, ytml_file):
+        self.ytml_file = ytml_file
+        self.templates = {}
+        self.global_styles = ""
+
+    def clean_text(self, text):
+        """
+        Cleans and normalizes the input text by:
+        - Stripping leading and trailing whitespace
+        - Replacing multiple spaces and newlines with a single space
+        - Normalizing Unicode characters to ASCII equivalents
+        """
+        # Normalize Unicode characters
+        normalized_text = unicodedata.normalize('NFKC', text)
+        # Remove extra spaces and newlines
+        cleaned_text = re.sub(r'\s+', ' ', normalized_text.strip())
+        return cleaned_text
+
+    def _preprocess_file(self, file_path):
+        """
+        Preprocess the YTML file to wrap content inside <code> tags in <![CDATA[ ... ]]>
+        """
+        with open(file_path, "r") as file:
+            content = file.read()
+
+        # Wrap <frame> content in <![CDATA[ ... ]]>
+        content = re.sub(
+            r"(<frame[^>]*>)(.*?)(</frame>)",
+            lambda match: f"{match.group(1)}<![CDATA[{match.group(2)}]]>{match.group(3)}",
+            content,
+            flags=re.DOTALL
+        )
+        return content
+
+    def parse(self):
+        """
+        Parse the YTML file and return structured JSON.
+        """
+        try:
+            # Preprocess the file to handle <code> content
+            preprocessed_content = self._preprocess_file(self.ytml_file)
+            root = ET.fromstring(preprocessed_content)
+        except ET.ParseError as e:
+            raise ValueError(f"Invalid YTML format: {e}")
+
+        if root.tag != "ytml":
+            raise ValueError("Invalid root element. Expected <ytml>.")
+
+        # Extract templates
+        self._extract_templates(root)
+
+        # Extract styles
+        style_tags = root.find("style")
+        self.global_styles = (
+            ET.tostring(style_tags, encoding="unicode").strip(
+            ) if style_tags is not None else None
+        )
+        # Parse composites
+        composites = []
+        for composite in root.findall("composite"):
+            # Check conditional logic
+            composites.append(self._parse_composite(composite))
+
+        # Extract global-music tag
+        global_music_tag = root.find("global-music")
+        global_music = []
+        if (global_music_tag != None):
+
+            global_music.append(
+                {
+                    "src": global_music_tag.get('src'),
+                    "start": parse_duration(global_music_tag.get('start')),
+                    "end": parse_duration(global_music_tag.get('end')),
+                    "loop": global_music_tag.get("loop") == "true",
+                }
+            )
+        return {"segments": composites, "global_music": global_music}
+
+    def _extract_templates(self, root):
+        """
+        Extract and store reusable templates.
+        """
+        for template in root.findall("template"):
+            template_id = template.get("id")
+            if not template_id:
+                raise ValueError("Template missing required 'id' attribute.")
+            if template_id in self.templates:
+                raise ValueError(f"Duplicate template ID found: {template_id}")
+            self.templates[template_id] = template
+
+    def _parse_composite(self, composite):
+        """
+        Parse a single composite, handling <code> tags as raw text.
+        """
+        parsed_composite = {
+            "frames": [],
+            "styles": self.global_styles,
+            "voiceovers": [],
+            "music": [],
+            "transitions": [],
+            "duration": '',
+            "static": False
+        }
+        current_time = 0.0
+
+        # Parse frames
+        for frame in composite.findall("frame"):
+            frame_data = frame.text.strip() if frame.text else ""
+            parsed_composite["frames"].append(frame_data)
+            parsed_composite['duration'] = parse_duration(
+                frame.get('duration') or '2s')
+            parsed_composite['frame_rate'] = frame.get('frame_rate')
+            parsed_composite["static"] = parse_boolean(frame.get("static"))
+
+        # Expand <use> tags with templates
+        for use in composite.findall("use"):
+            template_id = use.get("template")
+            if not template_id or template_id not in self.templates:
+                raise ValueError(
+                    f"Referenced template '{template_id}' not found.")
+            template_content = ET.tostring(
+                self.templates[template_id], encoding="unicode").strip()
+            parsed_composite["frames"].append(template_content)
+
+        # Parse voiceovers
+        for voice in composite.findall("voice"):
+            start = self._resolve_timing(voice.get("start"), current_time)
+            end = self._resolve_timing(voice.get("end"), start)
+            current_time = max(current_time, end)
+            parsed_composite["voiceovers"].append({
+                "text": self.clean_text(voice.text),
+                "start": start,
+                "end": end
+            })
+
+        # Parse music
+        for music in composite.findall("music"):
+            start = self._resolve_timing(music.get("start"), current_time)
+            end = self._resolve_timing(music.get("end"), start)
+            current_time = max(current_time, end)
+            parsed_composite["music"].append({
+                "src": music.get("src"),
+                "start": start,
+                "end": end,
+                "loop": music.get("loop") == "true",
+            })
+
+        # Parse transitions
+        for transition in composite.findall("transition"):
+            tType = transition.get("type")
+            duration = self._resolve_timing(transition.get("duration"), "1s")
+            parsed_composite["transitions"].append({
+                "type": tType,
+                "duration": f"{duration}s",
+            })
+
+        return parsed_composite
+
+    def _resolve_timing(self, timing, current_time):
+        """
+        Resolve timing values:
+        - Absolute values (e.g., "5s") remain unchanged.
+        - Relative values (e.g., "+2s") are added to the current time.
+        """
+        if timing is None:
+            return current_time
+        if timing.startswith("+"):
+            return current_time + float(parse_duration(timing[1:]))
+        return float(parse_duration(timing))
+
+
+# CLI for testing
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("Usage: python parser.py <ytml_file>")
+        sys.exit(1)
+
+    parser = YTMLParser(sys.argv[1])
+    try:
+        result = parser.parse()
+        print(json.dumps(result, indent=2))
+    except Exception as e:
+        print(f"Error: {e}")

ytml_toolkit-0.1.0/ytml/interpretron/test_parser.py

@@ -0,0 +1,43 @@
+import unittest
+from parser import YTMLParser
+
+
+class TestYTMLParser(unittest.TestCase):
+    def test_basic_parsing(self):
+        parser = YTMLParser("backend/interpretron/samples/basic.ytml")
+        result = parser.parse()
+        self.assertIn("segments", result)
+
+    def test_voice_parsing(self):
+        parser = YTMLParser("backend/interpretron/samples/voice.ytml")
+        result = parser.parse()
+        self.assertEqual(result["segments"][0]
+                         ["voiceovers"][0]["text"], "Hello!")
+
+    def test_music_parsing(self):
+        parser = YTMLParser("backend/interpretron/samples/music.ytml")
+        result = parser.parse()
+        self.assertEqual(result["segments"][0]["music"]
+                         [0]["src"], "background.mp3")
+
+    def test_dynamic_timing(self):
+        parser = YTMLParser("backend/interpretron/samples/dynamic_timing.ytml")
+        result = parser.parse()
+        self.assertEqual(result["segments"][0]["voiceovers"][0]["start"], 1.0)
+
+    def test_template_expansion(self):
+        parser = YTMLParser("backend/interpretron/samples/template.ytml")
+        result = parser.parse()
+        print(result)
+        self.assertIn("<div class='logo'>My Brand</div>",
+                      result["segments"][0]["frames"][0])
+
+    def test_error_handling(self):
+        parser = YTMLParser(
+            "backend/interpretron/samples/invalid_template.ytml")
+        with self.assertRaises(ValueError):
+            parser.parse()
+
+
+if __name__ == "__main__":
+    unittest.main()

ytml_toolkit-0.1.0/ytml/vocalforge/base_vocal_forge.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+
+class VocalForgeBase(ABC):
+    @abstractmethod
+    def generate_voiceover(self, text: str, output_file: str) -> str:
+        """
+        Generate a voiceover for the given text and save it to an audio file.
+        """
+        pass
+
+    @abstractmethod
+    def process_voiceovers(self, parsed_json: dict, output_dir: str = "voiceovers") -> list:
+        """
+        Process all voiceovers from the parsed JSON and generate audio files.
+        """
+        pass

ytml_toolkit-0.1.0/ytml/vocalforge/gtts_vocal_forge.py

@@ -0,0 +1,33 @@
+import os
+from gtts import gTTS
+
+from ytml.vocalforge.base_vocal_forge import VocalForgeBase
+
+
+class gTTSVocalForge(VocalForgeBase):
+
+    def generate_voiceover(self, text, output_file):
+        tts = gTTS(text)
+        tts.save(output_file)
+        return output_file
+
+    def process_voiceovers(self, parsed_json: dict, output_dir: str = "tmp/gtts_voiceovers") -> list:
+        """
+        Generate gtts voiceovers for all text in the parsed JSON.
+        """
+        os.makedirs(output_dir, exist_ok=True)
+        audio_metadata = []
+
+        for segment_idx, segment in enumerate(parsed_json.get("segments", [])):
+            for voice_idx, voice in enumerate(segment.get("voiceovers", [])):
+                text = voice["text"]
+                output_file = os.path.join(
+                    output_dir, f"segment{segment_idx+1}_voice{voice_idx+1}.mp3")
+                self.generate_voiceover(text, output_file)
+                audio_metadata.append({
+                    "file": output_file,
+                    "start": voice["start"],
+                    "end": voice["end"],
+                })
+
+        return audio_metadata

ytml_toolkit-0.1.0/ytml/vocalforge/xi_labs_vocal_forge.py

@@ -0,0 +1,94 @@
+import os
+import requests
+from dotenv import load_dotenv
+from ytml.vocalforge.base_vocal_forge import VocalForgeBase
+
+load_dotenv()  # Reads .env file and loads environment variables
+
+# Default fallback if environment variable is missing:
+DEFAULT_ELEVEN_LABS_API_KEY = "key"
+
+ELEVEN_LABS_API_KEY = os.getenv(
+    "ELEVEN_LABS_API_KEY", DEFAULT_ELEVEN_LABS_API_KEY)
+ELEVEN_LABS_URL = "https://api.elevenlabs.io/v1/text-to-speech"
+
+
+class ElevenLabsVocalForge(VocalForgeBase):
+    def __init__(self, voice_id, api_key=None):
+        """
+        If api_key is provided, use it. Otherwise, read from environment or the default.
+        """
+        self.api_key = api_key if api_key else ELEVEN_LABS_API_KEY
+
+        if(self.api_key=='key'):
+           raise Exception(
+            "Invalid Eleven Labs API key. Please set the 'ELEVEN_LABS_API_KEY' environment variable to use Eleven Labs, "
+            "or use the '--use-gtts' flag to fall back to Google Text-to-Speech.")
+
+        self.voice_id = voice_id
+
+    def generate_voiceover(self, text, output_file):
+        """
+        Generate voiceover for the given text and save it to an audio file.
+        """
+        headers = {
+            "xi-api-key": self.api_key,
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "text": text,
+        }
+        response = requests.post(
+            f"{ELEVEN_LABS_URL}/{self.voice_id}", json=payload, headers=headers)
+
+        if response.status_code == 200:
+            with open(output_file, "wb") as f:
+                f.write(response.content)
+            return output_file
+        else:
+            raise Exception(f"Error generating voice: {response.text}")
+
+    def process_voiceovers(self, parsed_json, output_dir="tmp/xi_voiceovers/1"):
+        """
+        Process all voiceovers from the parsed JSON.
+        """
+        os.makedirs(output_dir, exist_ok=True)
+        audio_metadata = []
+
+        for segment_idx, segment in enumerate(parsed_json.get("segments", [])):
+            for voice_idx, voice in enumerate(segment.get("voiceovers", [])):
+                text = voice["text"]
+                start = voice["start"]
+                end = voice["end"]
+                output_file = os.path.join(
+                    output_dir, f"segment{segment_idx+1}_voice{voice_idx+1}.mp3")
+
+                self.generate_voiceover(text, output_file)
+
+                audio_metadata.append({
+                    "file": output_file,
+                    "start": start,
+                    "end": end
+                })
+
+        return audio_metadata
+
+
+# Example Usage
+if __name__ == "__main__":
+    import json
+
+    parsed_json = {
+        "segments": [
+            {
+                "voiceovers": [
+                    {"text": "Hello and welcome!", "start": "0.5s", "end": "4.0s"}
+                ]
+            }
+        ]
+    }
+
+    # If you set ELEVEN_LABS_API_KEY in .env, it will be read automatically
+    forge = ElevenLabsVocalForge()
+    metadata = forge.process_voiceovers(parsed_json)
+    print(json.dumps(metadata, indent=2))

ytml_toolkit-0.1.0/ytml_toolkit.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.2
+Name: ytml-toolkit
+Version: 0.1.0
+Requires-Python: >=3.7
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: websockets
+Requires-Dist: boto3
+Requires-Dist: gtts
+Requires-Dist: pydub
+Requires-Dist: moviepy
+Requires-Dist: imageio
+Requires-Dist: imageio-ffmpeg
+Requires-Dist: playwright
+Requires-Dist: numpy
+Requires-Dist: requests
+Requires-Dist: python-dotenv
+Requires-Dist: beautifulsoup4
+Requires-Dist: lxml
+Requires-Dist: tqdm
+Requires-Dist: pyttsx3
+Requires-Dist: starlette
+Requires-Dist: colorama
+Dynamic: requires-dist
+Dynamic: requires-python

ytml_toolkit-0.1.0/ytml_toolkit.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+pyproject.toml
+setup.py
+ytml/__init__.py
+ytml/cli.py
+ytml/interpretron/__init__.py
+ytml/interpretron/parser.py
+ytml/interpretron/test_parser.py
+ytml/vocalforge/__init__.py
+ytml/vocalforge/base_vocal_forge.py
+ytml/vocalforge/gtts_vocal_forge.py
+ytml/vocalforge/test_voice.py
+ytml/vocalforge/xi_labs_vocal_forge.py
+ytml_toolkit.egg-info/PKG-INFO
+ytml_toolkit.egg-info/SOURCES.txt
+ytml_toolkit.egg-info/dependency_links.txt
+ytml_toolkit.egg-info/entry_points.txt
+ytml_toolkit.egg-info/requires.txt
+ytml_toolkit.egg-info/top_level.txt

ytml_toolkit-0.1.0/ytml_toolkit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ytml_toolkit-0.1.0/ytml_toolkit.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ytml = ytml.cli:main

ytml_toolkit-0.1.0/ytml_toolkit.egg-info/requires.txt

@@ -0,0 +1,19 @@
+fastapi
+uvicorn
+websockets
+boto3
+gtts
+pydub
+moviepy
+imageio
+imageio-ffmpeg
+playwright
+numpy
+requests
+python-dotenv
+beautifulsoup4
+lxml
+tqdm
+pyttsx3
+starlette
+colorama

ytml_toolkit-0.1.0/ytml_toolkit.egg-info/top_level.txt

@@ -0,0 +1 @@
+ytml