slide-stream 1.0.0__py3-none-any.whl

slide_stream/__init__.py

@@ -0,0 +1,5 @@
+"""Slide Stream - AI-powered tool for creating video presentations from Markdown."""
+
+__version__ = "1.0.0"
+__author__ = "Your Name"
+__email__ = "your.email@example.com"

slide_stream/cli.py

@@ -0,0 +1,242 @@
+"""Command line interface for Slide Stream."""
+
+import time
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from moviepy import ImageClip, concatenate_videoclips
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
+
+from . import __version__
+from .config import TEMP_DIR
+from .llm import get_llm_client, query_llm
+from .media import (
+    create_text_image,
+    create_video_fragment,
+    search_and_download_image,
+    text_to_speech,
+)
+from .parser import parse_markdown
+
+# Rich Console Initialization
+console = Console()
+err_console = Console(stderr=True, style="bold red")
+
+# Typer Application Initialization
+app = typer.Typer(
+    name="slide-stream",
+    help="""
+    SlideStream: An AI-powered tool to automatically create video presentations from text and Markdown.
+    """,
+    add_completion=False,
+    rich_markup_mode="markdown",
+)
+
+
+def version_callback(value: bool) -> None:
+    """Print the version of the application and exit."""
+    if value:
+        console.print(
+            f"[bold cyan]SlideStream[/bold cyan] version: [yellow]{__version__}[/yellow]"
+        )
+        raise typer.Exit()
+
+
+@app.command()
+def create(
+    input_file: Annotated[
+        typer.FileText,
+        typer.Option(
+            "--input",
+            "-i",
+            help="Path to the input Markdown file.",
+            rich_help_panel="Input/Output Options",
+        ),
+    ],
+    output_filename: Annotated[
+        str,
+        typer.Option(
+            "--output",
+            "-o",
+            help="Filename for the output video.",
+            rich_help_panel="Input/Output Options",
+        ),
+    ] = "output_video.mp4",
+    llm_provider: Annotated[
+        str,
+        typer.Option(
+            help="Select the LLM provider for text enhancement.",
+            rich_help_panel="AI & Content Options",
+        ),
+    ] = "none",
+    image_source: Annotated[
+        str,
+        typer.Option(
+            help="Choose the source for slide images.",
+            rich_help_panel="AI & Content Options",
+        ),
+    ] = "unsplash",
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            help="Show application version and exit.",
+            callback=version_callback,
+            is_eager=True,
+        ),
+    ] = False,
+) -> None:
+    """Create a video from a Markdown file."""
+    console.print(
+        Panel.fit(
+            "[bold cyan]🚀 Starting SlideStream! 🚀[/bold cyan]",
+            border_style="green",
+        )
+    )
+
+    # Read input file
+    markdown_input = input_file.read()
+    if not markdown_input.strip():
+        err_console.print("Input file is empty. Exiting.")
+        raise typer.Exit(code=1)
+
+    # Setup temporary directory
+    temp_dir = Path(TEMP_DIR)
+    temp_dir.mkdir(exist_ok=True)
+
+    # Initialize LLM client
+    llm_client = None
+    if llm_provider != "none":
+        try:
+            llm_client = get_llm_client(llm_provider)
+            console.print(
+                f"✅ LLM Provider Initialized: [bold green]{llm_provider}[/bold green]"
+            )
+        except (ImportError, ValueError) as e:
+            err_console.print(f"Error initializing LLM: {e}")
+            raise typer.Exit(code=1)
+
+    # Parse the Markdown
+    console.print("\n[bold]1. Parsing Markdown...[/bold]")
+    slides = parse_markdown(markdown_input)
+    if not slides:
+        err_console.print("No slides found in the Markdown file. Exiting.")
+        raise typer.Exit(code=1)
+    console.print(f"📄 Found [bold yellow]{len(slides)}[/bold yellow] slides.")
+
+    # Process each slide with Rich progress bar
+    video_fragments = []
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+        transient=True,
+    ) as progress:
+        process_task = progress.add_task(
+            "[yellow]Processing Slides...", total=len(slides)
+        )
+
+        for i, slide in enumerate(slides):
+            slide_num = i + 1
+            progress.update(
+                process_task,
+                description=f"[yellow]Processing Slide {slide_num}/{len(slides)}: '{slide['title']}'[/yellow]",
+            )
+
+            raw_text = f"Title: {slide['title']}. Content: {' '.join(slide['content'])}"
+            speech_text = raw_text
+            search_query = slide["title"]
+
+            # LLM Processing
+            if llm_client:
+                speech_prompt = f"Convert the following slide points into a natural, flowing script for a voiceover. Speak conversationally. Directly output the script and nothing else.\n\n{raw_text}"
+                natural_speech = query_llm(
+                    llm_client, llm_provider, speech_prompt, console
+                )
+                if natural_speech:
+                    speech_text = natural_speech
+
+                if image_source == "unsplash":
+                    search_prompt = f"Generate a concise, descriptive search query for a stock photo website (like Unsplash) to find a high-quality, relevant image for this topic. Output only the query. Topic:\n\n{raw_text}"
+                    improved_query = query_llm(
+                        llm_client, llm_provider, search_prompt, console
+                    )
+                    if improved_query:
+                        search_query = improved_query.strip().replace('"', "")
+
+            # File paths
+            img_path = temp_dir / f"slide_{slide_num}.png"
+            audio_path = temp_dir / f"slide_{slide_num}.mp3"
+            fragment_path = temp_dir / f"fragment_{slide_num}.mp4"
+
+            # Image sourcing, audio, and video creation
+            if image_source == "unsplash":
+                search_and_download_image(search_query, str(img_path))
+            else:
+                create_text_image(slide["title"], slide["content"], str(img_path))
+
+            audio_file = text_to_speech(speech_text, str(audio_path))
+            fragment_file = create_video_fragment(
+                str(img_path),
+                str(audio_path) if audio_file else None,
+                str(fragment_path),
+            )
+
+            if fragment_file:
+                video_fragments.append(fragment_file)
+
+            progress.update(process_task, advance=1)
+            time.sleep(0.1)  # Small delay for smoother progress bar updates
+
+    # Combine video fragments
+    console.print("\n[bold]2. Combining Video Fragments...[/bold]")
+    if video_fragments:
+        try:
+            clips = [
+                ImageClip(f).set_duration(ImageClip(f).duration)
+                for f in video_fragments
+            ]
+            final_clip = concatenate_videoclips(clips)
+            final_clip.write_videofile(
+                output_filename, fps=24, codec="libx264", audio_codec="aac", logger=None
+            )
+
+            # Clean up clips
+            for clip in clips:
+                clip.close()
+            final_clip.close()
+
+            console.print(
+                Panel(
+                    f"🎉 [bold green]Video creation complete![/bold green] 🎉\n\nOutput file: [yellow]{output_filename}[/yellow]",
+                    border_style="green",
+                    expand=False,
+                )
+            )
+        except Exception as e:
+            err_console.print(f"Error combining video fragments: {e}")
+            raise typer.Exit(code=1)
+    else:
+        err_console.print(
+            "No video fragments were created, so the final video could not be generated."
+        )
+        raise typer.Exit(code=1)
+
+    # Cleanup
+    console.print("\n[bold]3. Cleaning up temporary files...[/bold]")
+    try:
+        for file_path in temp_dir.iterdir():
+            if file_path.is_file():
+                file_path.unlink()
+        temp_dir.rmdir()
+        console.print("✅ Cleanup complete.")
+    except Exception as e:
+        err_console.print(f"Warning: Could not clean up temporary files: {e}")
+
+
+if __name__ == "__main__":
+    app()

slide_stream/config.py

@@ -0,0 +1,25 @@
+"""Configuration constants for Slide Stream."""
+
+
+# Video settings
+VIDEO_RESOLUTION = (1920, 1080)
+SLIDE_DURATION_PADDING = 1.0
+DEFAULT_SLIDE_DURATION = 5.0
+VIDEO_FPS = 24
+VIDEO_CODEC = "libx264"
+AUDIO_CODEC = "aac"
+
+# Image settings
+IMAGE_DOWNLOAD_TIMEOUT = 15
+BG_COLOR = "black"
+
+# Directories
+TEMP_DIR = "temp_files"
+
+# Font settings
+DEFAULT_TITLE_FONT_SIZE = 100
+DEFAULT_CONTENT_FONT_SIZE = 60
+FONT_COLOR = "white"
+
+# Text wrapping
+MAX_LINE_WIDTH = 50

slide_stream/llm.py

@@ -0,0 +1,118 @@
+"""LLM integration for Slide Stream."""
+
+import os
+from typing import Any
+
+from rich.console import Console
+
+err_console = Console(stderr=True, style="bold red")
+
+
+def get_llm_client(provider: str) -> Any:
+    """Get LLM client based on provider."""
+    if provider == "gemini":
+        try:
+            import google.generativeai as genai
+
+            api_key = os.getenv("GEMINI_API_KEY")
+            if not api_key:
+                raise ValueError("GEMINI_API_KEY environment variable not set.")
+            genai.configure(api_key=api_key)
+            return genai.GenerativeModel("gemini-1.5-flash")
+        except ImportError:
+            raise ImportError(
+                "Gemini library not found. Please install with: pip install slide-stream[gemini]"
+            )
+
+    elif provider == "openai":
+        try:
+            from openai import OpenAI
+
+            api_key = os.getenv("OPENAI_API_KEY")
+            if not api_key:
+                raise ValueError("OPENAI_API_KEY environment variable not set.")
+            return OpenAI(api_key=api_key)
+        except ImportError:
+            raise ImportError(
+                "OpenAI library not found. Please install with: pip install slide-stream[openai]"
+            )
+
+    elif provider == "claude":
+        try:
+            import anthropic
+
+            api_key = os.getenv("ANTHROPIC_API_KEY")
+            if not api_key:
+                raise ValueError("ANTHROPIC_API_KEY environment variable not set.")
+            return anthropic.Anthropic(api_key=api_key)
+        except ImportError:
+            raise ImportError(
+                "Anthropic library not found. Please install with: pip install slide-stream[claude]"
+            )
+
+    elif provider == "groq":
+        try:
+            from groq import Groq
+
+            api_key = os.getenv("GROQ_API_KEY")
+            if not api_key:
+                raise ValueError("GROQ_API_KEY environment variable not set.")
+            return Groq(api_key=api_key)
+        except ImportError:
+            raise ImportError(
+                "Groq library not found. Please install with: pip install slide-stream[groq]"
+            )
+
+    elif provider == "ollama":
+        try:
+            from openai import OpenAI
+
+            base_url = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+            return OpenAI(base_url=f"{base_url}/v1", api_key="ollama")
+        except ImportError:
+            raise ImportError(
+                "OpenAI library not found. Please install with: pip install slide-stream[openai]"
+            )
+
+    else:
+        raise ValueError(f"Unknown LLM provider: {provider}")
+
+
+def query_llm(
+    client: Any, provider: str, prompt_text: str, rich_console: Console
+) -> str | None:
+    """Query LLM with given prompt."""
+    rich_console.print("  - Querying LLM...")
+
+    try:
+        if provider == "gemini":
+            response = client.generate_content(prompt_text)
+            return response.text
+
+        elif provider in ["openai", "ollama"]:
+            model = "gpt-4o" if provider == "openai" else "llama3.1"
+            response = client.chat.completions.create(
+                model=model, messages=[{"role": "user", "content": prompt_text}]
+            )
+            return response.choices[0].message.content
+
+        elif provider == "claude":
+            response = client.messages.create(
+                model="claude-3-sonnet-20240229",
+                max_tokens=1024,
+                messages=[{"role": "user", "content": prompt_text}],
+            )
+            return response.content[0].text
+
+        elif provider == "groq":
+            response = client.chat.completions.create(
+                model="llama3-8b-8192",
+                messages=[{"role": "user", "content": prompt_text}],
+            )
+            return response.choices[0].message.content
+
+        return None
+
+    except Exception as e:
+        err_console.print(f"  - LLM Error: {e}")
+        return None

slide_stream/media.py

@@ -0,0 +1,149 @@
+"""Media handling functionality for Slide Stream."""
+
+import os
+import textwrap
+
+import requests
+from gtts import gTTS
+from moviepy import AudioFileClip, ImageClip
+from PIL import Image, ImageDraw, ImageFont
+from rich.console import Console
+
+from .config import (
+    BG_COLOR,
+    DEFAULT_CONTENT_FONT_SIZE,
+    DEFAULT_SLIDE_DURATION,
+    DEFAULT_TITLE_FONT_SIZE,
+    FONT_COLOR,
+    IMAGE_DOWNLOAD_TIMEOUT,
+    MAX_LINE_WIDTH,
+    SLIDE_DURATION_PADDING,
+    VIDEO_CODEC,
+    VIDEO_FPS,
+    VIDEO_RESOLUTION,
+)
+
+err_console = Console(stderr=True, style="bold red")
+
+
+def search_and_download_image(query: str, filename: str) -> str:
+    """Download image from Unsplash based on search query."""
+    try:
+        url = f"https://source.unsplash.com/random/{VIDEO_RESOLUTION[0]}x{VIDEO_RESOLUTION[1]}/?{query.replace(' ', ',')}"
+        response = requests.get(
+            url, timeout=IMAGE_DOWNLOAD_TIMEOUT, allow_redirects=True
+        )
+        response.raise_for_status()
+
+        with open(filename, "wb") as f:
+            f.write(response.content)
+
+        return filename
+
+    except requests.exceptions.RequestException as e:
+        err_console.print(f"  - Image download error: {e}. Using a placeholder.")
+        return create_text_image("Image not found", [f"Query: {query}"], filename)
+
+
+def create_text_image(title: str, content_items: list, filename: str) -> str:
+    """Create a text-based image for slides."""
+    img = Image.new("RGB", VIDEO_RESOLUTION, color=BG_COLOR)
+    draw = ImageDraw.Draw(img)
+
+    # Try to load custom fonts, fall back to default
+    try:
+        title_font = ImageFont.truetype("arial.ttf", DEFAULT_TITLE_FONT_SIZE)
+        content_font = ImageFont.truetype("arial.ttf", DEFAULT_CONTENT_FONT_SIZE)
+    except OSError:
+        try:
+            # Try alternative common font names
+            title_font = ImageFont.truetype("DejaVuSans.ttf", DEFAULT_TITLE_FONT_SIZE)
+            content_font = ImageFont.truetype(
+                "DejaVuSans.ttf", DEFAULT_CONTENT_FONT_SIZE
+            )
+        except OSError:
+            title_font = ImageFont.load_default()
+            content_font = ImageFont.load_default()
+
+    # Draw title
+    draw.text(
+        (VIDEO_RESOLUTION[0] * 0.1, VIDEO_RESOLUTION[1] * 0.1),
+        title,
+        font=title_font,
+        fill=FONT_COLOR,
+    )
+
+    # Draw content items
+    y_pos = VIDEO_RESOLUTION[1] * 0.3
+    for item in content_items:
+        wrapped_lines = textwrap.wrap(f"• {item}", width=MAX_LINE_WIDTH)
+        for line in wrapped_lines:
+            draw.text(
+                (VIDEO_RESOLUTION[0] * 0.1, y_pos),
+                line,
+                font=content_font,
+                fill=FONT_COLOR,
+            )
+            y_pos += 70
+        y_pos += 30
+
+    img.save(filename)
+    return filename
+
+
+def text_to_speech(text: str, filename: str) -> str | None:
+    """Convert text to speech using gTTS."""
+    try:
+        tts = gTTS(text=text, lang="en")
+        tts.save(filename)
+        return filename
+    except Exception as e:
+        err_console.print(f"  - Audio generation error: {e}")
+        return None
+
+
+def create_video_fragment(
+    image_path: str, audio_path: str | None, output_path: str
+) -> str | None:
+    """Create video fragment from image and audio."""
+    try:
+        # Load audio if it exists
+        audio_clip = None
+        if audio_path and os.path.exists(audio_path):
+            audio_clip = AudioFileClip(audio_path)
+
+        # Determine duration
+        duration = (
+            audio_clip.duration + SLIDE_DURATION_PADDING
+            if audio_clip
+            else DEFAULT_SLIDE_DURATION
+        )
+
+        # Create image clip
+        image_clip = ImageClip(image_path, duration=duration).set_position("center")
+
+        # Resize image to fit resolution if needed
+        if image_clip.h > VIDEO_RESOLUTION[1]:
+            image_clip = image_clip.resize(height=VIDEO_RESOLUTION[1])
+        if image_clip.w > VIDEO_RESOLUTION[0]:
+            image_clip = image_clip.resize(width=VIDEO_RESOLUTION[0])
+
+        # Combine with audio
+        final_clip = image_clip.set_audio(audio_clip) if audio_clip else image_clip
+
+        # Write video file
+        final_clip.write_videofile(
+            output_path, fps=VIDEO_FPS, codec=VIDEO_CODEC, logger=None
+        )
+
+        # Clean up clips
+        if audio_clip:
+            audio_clip.close()
+        image_clip.close()
+        final_clip.close()
+
+        return output_path
+
+    except Exception as e:
+        err_console.print(f"  - Video fragment creation error: {e}")
+        return None

slide_stream/parser.py

@@ -0,0 +1,38 @@
+"""Markdown parsing functionality for Slide Stream."""
+
+from typing import Any
+
+import markdown
+from bs4 import BeautifulSoup
+
+
+def parse_markdown(markdown_text: str) -> list[dict[str, Any]]:
+    """Parse markdown text into slide data."""
+    html = markdown.markdown(markdown_text)
+    soup = BeautifulSoup(html, "html.parser")
+    slides = []
+
+    for header in soup.find_all("h1"):
+        slide_title = header.get_text()
+
+        # Find the next sibling that is a list (ul or ol)
+        next_sibling = header.find_next_sibling()
+        content_items = []
+
+        while next_sibling:
+            if next_sibling.name in ["ul", "ol"]:
+                content_items = [
+                    item.get_text() for item in next_sibling.find_all("li")
+                ]
+                break
+            elif next_sibling.name == "p":
+                # If it's a paragraph, add it as content
+                content_items.append(next_sibling.get_text())
+            elif next_sibling.name in ["h1", "h2", "h3"]:
+                # Stop if we hit another header
+                break
+            next_sibling = next_sibling.find_next_sibling()
+
+        slides.append({"title": slide_title, "content": content_items})
+
+    return slides

slide_stream-1.0.0.dist-info/METADATA

@@ -0,0 +1,204 @@
+Metadata-Version: 2.4
+Name: slide-stream
+Version: 1.0.0
+Summary: An AI-powered tool to automatically create video presentations from text and Markdown
+Project-URL: Homepage, https://github.com/yourusername/slide-stream
+Project-URL: Repository, https://github.com/yourusername/slide-stream
+Project-URL: Issues, https://github.com/yourusername/slide-stream/issues
+Author-email: Your Name <your.email@example.com>
+License: MIT
+License-File: LICENSE
+Keywords: ai,cli,markdown,presentation,video
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.10
+Requires-Dist: anthropic>=0.7.0; extra == 'claude'
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: google-generativeai>=0.3.0; extra == 'gemini'
+Requires-Dist: groq>=0.4.0; extra == 'groq'
+Requires-Dist: gtts>=2.4.0
+Requires-Dist: markdown>=3.5.0
+Requires-Dist: moviepy>=1.0.3
+Requires-Dist: openai>=1.0.0; extra == 'openai'
+Requires-Dist: pillow>=10.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: typing-extensions>=4.8.0
+Provides-Extra: all-ai
+Requires-Dist: anthropic>=0.7.0; extra == 'all-ai'
+Requires-Dist: google-generativeai>=0.3.0; extra == 'all-ai'
+Requires-Dist: groq>=0.4.0; extra == 'all-ai'
+Requires-Dist: openai>=1.0.0; extra == 'all-ai'
+Provides-Extra: claude
+Requires-Dist: anthropic>=0.7.0; extra == 'claude'
+Provides-Extra: dev
+Requires-Dist: basedpyright>=1.8.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.5.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.12.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: gemini
+Requires-Dist: google-generativeai>=0.3.0; extra == 'gemini'
+Provides-Extra: groq
+Requires-Dist: groq>=0.4.0; extra == 'groq'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# Slide Stream
+
+🎬 An AI-powered tool to automatically create video presentations from Markdown files.
+
+[![PyPI version](https://badge.fury.io/py/slide-stream.svg)](https://badge.fury.io/py/slide-stream)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Transform your Markdown documents into professional video presentations with AI-powered content enhancement, automatic image sourcing, and natural text-to-speech narration.
+
+## ✨ Features
+
+- 📝 **Markdown to Video**: Convert Markdown files into professional video presentations
+- 🤖 **AI Enhancement**: Improve content using OpenAI, Gemini, Claude, Groq, or Ollama
+- 🖼️ **Smart Images**: Automatic image sourcing from Unsplash or generate text-based slides
+- 🎙️ **Text-to-Speech**: Natural narration using Google Text-to-Speech
+- 🎨 **Customizable**: Professional video output with configurable settings
+- ⚡ **Modern CLI**: Built with Typer and Rich for excellent user experience
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+pip install slide-stream
+```
+
+### Basic Usage
+
+Create a simple Markdown file:
+
+```markdown
+# Welcome to My Presentation
+
+- This is the first point
+- Here's another important point
+- And a final thought
+
+# Second Slide
+
+- More content here
+- Additional information
+- Conclusion
+```
+
+Generate your video:
+
+```bash
+slide-stream create -i presentation.md -o my-video.mp4
+```
+
+## 🔧 Installation Options
+
+### Core Installation
+```bash
+pip install slide-stream
+```
+
+### With AI Providers
+```bash
+# For OpenAI GPT models
+pip install slide-stream[openai]
+
+# For Google Gemini
+pip install slide-stream[gemini]
+
+# For Anthropic Claude
+pip install slide-stream[claude]
+
+# For Groq (fast inference)
+pip install slide-stream[groq]
+
+# For all AI providers
+pip install slide-stream[all-ai]
+```
+
+## 🎯 Usage Examples
+
+### Basic video creation
+```bash
+slide-stream create -i slides.md -o presentation.mp4
+```
+
+### With AI enhancement
+```bash
+# Set your API key
+export OPENAI_API_KEY="your-api-key-here"
+
+# Create enhanced video
+slide-stream create \
+  -i slides.md \
+  -o presentation.mp4 \
+  --llm-provider openai \
+  --image-source unsplash
+```
+
+### Text-only slides (no internet required)
+```bash
+slide-stream create \
+  -i slides.md \
+  -o presentation.mp4 \
+  --image-source text
+```
+
+## 🔑 Environment Variables
+
+Set these environment variables for AI providers:
+
+```bash
+# OpenAI
+export OPENAI_API_KEY="your-openai-key"
+
+# Google Gemini
+export GEMINI_API_KEY="your-gemini-key"
+
+# Anthropic Claude
+export ANTHROPIC_API_KEY="your-claude-key"
+
+# Groq
+export GROQ_API_KEY="your-groq-key"
+
+# Ollama (local)
+export OLLAMA_BASE_URL="http://localhost:11434"
+```
+
+## 📋 Requirements
+
+- Python 3.10+
+- FFmpeg (for video processing)
+- Internet connection (for Unsplash images and AI providers)
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Built with [Typer](https://typer.tiangolo.com/) for the CLI
+- [Rich](https://rich.readthedocs.io/) for beautiful terminal output
+- [MoviePy](https://moviepy.readthedocs.io/) for video processing
+- [Pillow](https://pillow.readthedocs.io/) for image handling

slide_stream-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+slide_stream/__init__.py,sha256=YPuLXtn8zbpE3HN3zAjG63REnJzF7z4blOP5r_Tu7c4,170
+slide_stream/cli.py,sha256=9ImnPa6y7xPY6mqZOJ0u_B1FlmfDE6Ea67dsPOyVFUY,8089
+slide_stream/config.py,sha256=AEenMpsNuhMawBvnkH0gN26qT7pYaf5puiU9UWi59Ow,456
+slide_stream/llm.py,sha256=c3_zRM9Nu6T6ixyTLPK31BGSsSfkn4TOyHjTxwugWco,3949
+slide_stream/media.py,sha256=amNkYilDaARgCU260fEELAy3joJJYJvBZat8cN9Cmuw,4576
+slide_stream/parser.py,sha256=_9Mq0Xngg7_u6X-SmVE4xZjYAKUwI9ALWHoPM1cBrKQ,1232
+slide_stream-1.0.0.dist-info/METADATA,sha256=H62mOMRozxGEJX2ZqNSJNexUPbiePDvyHX-iK_2Mqv4,5873
+slide_stream-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+slide_stream-1.0.0.dist-info/entry_points.txt,sha256=g7GgszRmRunGIcmwanS_RX2_I44odc0WGQrLdikuSbc,54
+slide_stream-1.0.0.dist-info/licenses/LICENSE,sha256=g1qHuBwyB3NcBzHvVFp-N1vV6q7Y8iDu1YDY01cp3p8,1081
+slide_stream-1.0.0.dist-info/RECORD,,

slide_stream-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

slide_stream-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+slide-stream = slide_stream.cli:app

slide_stream-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Slide Stream Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.