bonanza-ugc 0.1.0__tar.gz

bonanza_ugc-0.1.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: bonanza-ugc
+Version: 0.1.0
+Summary: AI-generated UGC videos via Higgsfield Marketing Studio
+Author: Bonanza Labs
+License-Expression: MIT
+Keywords: ugc,ai,video,higgsfield,marketing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+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
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Bonanza UGC
+
+AI-generated UGC videos via Higgsfield Marketing Studio.
+
+## Install
+
+```bash
+pip install bonanza-ugc
+```
+
+## Quick Start
+
+```python
+from bonanza_ugc import UGCGenerator, UGCConfig
+
+gen = UGCGenerator()
+video = gen.generate(
+    prompt="A stylish young woman shows off her silver chain necklace...",
+    avatar="mei",
+    mode="ugc",
+    duration=15,
+)
+print(f"Video URL: {video.result_url}")
+print(f"Virality: {video.virality_score}/100")
+```
+
+## CLI
+
+```bash
+# Generate a video
+ugc generate --prompt "..." --avatar mei --mode ugc
+
+# Use a template
+ugc generate --template silverjstore --product "Venetian Chain" --avatar mei
+
+# Score virality
+ugc score <video_path_or_url>
+
+# List avatars
+ugc avatars
+
+# Batch generate
+ugc batch --leads leads.json --mode ugc
+```
+
+## Features
+
+- 🎬 Generate UGC videos with AI avatars
+- 📊 Score video virality with Brain Activity analysis
+- 🎯 Prompt templates for product categories
+- 📦 Batch generation support
+- 🔄 Product URL fetching and integration
+
+## License
+
+MIT

bonanza_ugc-0.1.0/README.md

@@ -0,0 +1,56 @@
+# Bonanza UGC
+
+AI-generated UGC videos via Higgsfield Marketing Studio.
+
+## Install
+
+```bash
+pip install bonanza-ugc
+```
+
+## Quick Start
+
+```python
+from bonanza_ugc import UGCGenerator, UGCConfig
+
+gen = UGCGenerator()
+video = gen.generate(
+    prompt="A stylish young woman shows off her silver chain necklace...",
+    avatar="mei",
+    mode="ugc",
+    duration=15,
+)
+print(f"Video URL: {video.result_url}")
+print(f"Virality: {video.virality_score}/100")
+```
+
+## CLI
+
+```bash
+# Generate a video
+ugc generate --prompt "..." --avatar mei --mode ugc
+
+# Use a template
+ugc generate --template silverjstore --product "Venetian Chain" --avatar mei
+
+# Score virality
+ugc score <video_path_or_url>
+
+# List avatars
+ugc avatars
+
+# Batch generate
+ugc batch --leads leads.json --mode ugc
+```
+
+## Features
+
+- 🎬 Generate UGC videos with AI avatars
+- 📊 Score video virality with Brain Activity analysis
+- 🎯 Prompt templates for product categories
+- 📦 Batch generation support
+- 🔄 Product URL fetching and integration
+
+## License
+
+MIT

bonanza_ugc-0.1.0/bonanza_ugc/__init__.py

@@ -0,0 +1,9 @@
+"""Bonanza UGC — AI-generated UGC videos via Higgsfield Marketing Studio."""
+
+__version__ = "0.1.0"
+__author__ = "Bonanza Labs"
+
+from .generator import UGCGenerator
+from .config import UGCConfig
+
+__all__ = ["UGCGenerator", "UGCConfig"]

bonanza_ugc-0.1.0/bonanza_ugc/cli.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from bonanza_ugc.generator import UGCGenerator, UGCVideo
+from bonanza_ugc.config import UGCConfig
+import logging
+
+
+def cmd_generate(args):
+    """Generate a UGC video."""
+    gen = UGCGenerator(UGCConfig.from_env())
+
+    if args.template:
+        video = gen.generate_from_template(
+            template=args.template,
+            product_name=args.product or "silver jewelry",
+            avatar=args.avatar,
+            mode=args.mode,
+            gender=args.gender or "woman",
+            duration=args.duration,
+            resolution=args.resolution,
+        )
+    else:
+        if not args.prompt:
+            print("❌ --prompt is required when not using --template")
+            sys.exit(1)
+
+        video = gen.generate(
+            prompt=args.prompt,
+            avatar=args.avatar,
+            mode=args.mode,
+            duration=args.duration,
+            resolution=args.resolution,
+            aspect_ratio=args.aspect_ratio,
+            product_url=args.product_url or "",
+            wait=not args.no_wait,
+        )
+
+    print(f"\n🎬 UGC Video Generated!")
+    print(f"   Job ID:    {video.job_id}")
+    print(f"   Status:    {video.status}")
+    print(f"   URL:       {video.result_url}")
+    if video.local_path:
+        print(f"   Local:     {video.local_path}")
+    if video.virality_score:
+        print(f"   Virality:  {video.virality_score}/100")
+    print()
+
+    # Save result
+    result_file = Path(gen.output_dir) / f"result_{video.job_id[:8]}.json"
+    with open(result_file, "w") as f:
+        json.dump(video.to_dict(), f, indent=2)
+    print(f"   Result saved: {result_file}")
+
+
+def cmd_score(args):
+    """Score a video's virality."""
+    gen = UGCGenerator(UGCConfig.from_env())
+
+    video = args.video
+    # If it's a job ID, get the result URL first
+    if len(video) < 40 and not video.startswith("http") and not Path(video).exists():
+        # It's likely a local file in output dir
+        local = Path(gen.output_dir) / video
+        if local.exists():
+            video = str(local)
+
+    score = gen.score(video)
+
+    print(f"\n📊 Virality Score")
+    print(f"   Overall:    {score.overall_score}/100")
+    print(f"   Hook:       {score.hook_score}/100")
+    print(f"   Viral:      {score.viral_potential}/100")
+    print(f"   Engagement: {score.brain_engagement}/100")
+    print(f"   Sustain:    {score.sustain_score}/100")
+    print(f"   Peak at:    {score.peak_second}s")
+    if score.recommendations:
+        print(f"\n   💡 Recommendations:")
+        for rec in score.recommendations:
+            print(f"      • {rec}")
+    print()
+
+
+def cmd_avatars(args):
+    """List available avatars."""
+    gen = UGCGenerator(UGCConfig.from_env())
+    avatars = gen.list_avatars()
+
+    if not avatars:
+        # Fallback to config
+        print("Available avatars (from config):")
+        for name, id in gen.config.avatars.items():
+            print(f"  {name:12s}  {id}")
+    else:
+        print("Available avatars:")
+        for av in avatars:
+            name = av.get("name", "?")
+            gender = av.get("gender", "?")
+            av_id = av.get("id", "?")
+            print(f"  {name:12s}  {gender:6s}  {av_id}")
+
+
+def cmd_products(args):
+    """List imported products."""
+    gen = UGCGenerator(UGCConfig.from_env())
+    products = gen.list_products()
+
+    if not products:
+        print("No products imported yet.")
+    else:
+        print("Imported products:")
+        for p in products:
+            title = p.get("title", "?")
+            status = p.get("status", "?")
+            p_id = p.get("id", "?")[:8]
+            print(f"  {p_id}  {status:12s}  {title}")
+
+
+def cmd_batch(args):
+    """Generate videos for multiple products/scenarios."""
+    gen = UGCGenerator(UGCConfig.from_env())
+
+    leads_path = Path(args.leads)
+    if not leads_path.exists():
+        print(f"❌ File not found: {args.leads}")
+        sys.exit(1)
+
+    with open(leads_path) as f:
+        items = json.load(f)
+
+    print(f"🎬 Batch generation: {len(items)} videos")
+    print()
+
+    results = []
+    for i, item in enumerate(items, 1):
+        prompt = item.get("prompt", "")
+        avatar = item.get("avatar", args.avatar)
+        mode = item.get("mode", args.mode)
+        product_url = item.get("product_url", "")
+
+        print(f"  [{i}/{len(items)}] Generating: {prompt[:60]}...")
+
+        try:
+            video = gen.generate(
+                prompt=prompt,
+                avatar=avatar,
+                mode=mode,
+                duration=args.duration,
+                product_url=product_url,
+                wait=True,
+            )
+            results.append(video.to_dict())
+            print(f"    ✅ Score: {video.virality_score}/100 | {video.result_url[:60]}...")
+        except Exception as e:
+            print(f"    ❌ Failed: {e}")
+            results.append({"error": str(e), "prompt": prompt})
+
+    # Save batch results
+    batch_file = Path(gen.output_dir) / f"batch_{int(__import__('time').time())}.json"
+    with open(batch_file, "w") as f:
+        json.dump(results, f, indent=2)
+
+    print(f"\n✅ Batch complete! Results: {batch_file}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Bonanza UGC — AI-generated UGC videos",
+        prog="ugc.py",
+    )
+    sub = parser.add_subparsers(dest="command", help="Commands")
+
+    # Generate
+    p_gen = sub.add_parser("generate", help="Generate a UGC video")
+    p_gen.add_argument("--prompt", help="Video prompt")
+    p_gen.add_argument("--avatar", default="mei", help="Avatar name or ID (default: mei)")
+    p_gen.add_argument("--mode", default="ugc", choices=UGCGenerator.MODES, help="Marketing Studio mode")
+    p_gen.add_argument("--duration", type=int, default=15, help="Duration in seconds (10, 15)")
+    p_gen.add_argument("--resolution", default="720p", help="Resolution (720p, 1080p)")
+    p_gen.add_argument("--aspect-ratio", default="9:16", help="Aspect ratio (9:16, 16:9)")
+    p_gen.add_argument("--product-url", help="Product URL to fetch")
+    p_gen.add_argument("--template", help="Prompt template (silverjstore)")
+    p_gen.add_argument("--product", help="Product name for template")
+    p_gen.add_argument("--gender", help="Gender for template")
+    p_gen.add_argument("--no-wait", action="store_true", help="Don't wait for completion")
+
+    # Score
+    p_score = sub.add_parser("score", help="Score video virality")
+    p_score.add_argument("video", help="Video file path, URL, or job ID")
+
+    # Avatars
+    sub.add_parser("avatars", help="List available avatars")
+
+    # Products
+    sub.add_parser("products", help="List imported products")
+
+    # Batch
+    p_batch = sub.add_parser("batch", help="Batch generate videos")
+    p_batch.add_argument("--leads", required=True, help="JSON file with prompts")
+    p_batch.add_argument("--avatar", default="mei", help="Default avatar")
+    p_batch.add_argument("--mode", default="ugc", help="Default mode")
+    p_batch.add_argument("--duration", type=int, default=15, help="Duration")
+
+    args = parser.parse_args()
+
+    commands = {
+        "generate": cmd_generate,
+        "score": cmd_score,
+        "avatars": cmd_avatars,
+        "products": cmd_products,
+        "batch": cmd_batch,
+    }
+
+    if args.command in commands:
+        commands[args.command](args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    import logging
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+    main()

bonanza_ugc-0.1.0/bonanza_ugc/config.py

@@ -0,0 +1,75 @@
+"""Configuration for Bonanza UGC."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class UGCConfig:
+    """UGC generation configuration."""
+
+    # Higgsfield defaults
+    default_avatar: str = "44ee57aa"  # Mei (female, diverse)
+    default_mode: str = "ugc"
+    default_duration: int = 15
+    default_resolution: str = "720p"
+    default_aspect_ratio: str = "9:16"
+    default_generate_audio: bool = True
+
+    # Output
+    output_dir: str = str(Path.home() / ".openclaw" / "workspace" / "ugc-output")
+
+    # Virality scoring
+    score_virality: bool = True
+    min_virality_score: int = 40  # Warn if below this
+
+    # Product config (SilverJStore defaults)
+    product_base_url: str = "https://silverjstore.com"
+
+    # Avatar mapping (name → id)
+    avatars: dict = None
+
+    def __post_init__(self):
+        if self.avatars is None:
+            self.avatars = {
+                "mei": "44ee57aa-d1f4-4a0a-a55f-cdf9dacee265",
+                "yuna": "24d6d9cc-42df-43c7-bdfc-be06f317b924",
+                "adriana": "aa9260cc",
+                "clara": "daf4bf2e",
+                "sofia": "bba3087a",
+                "valentina": "cd6fb78c",
+                "jia": "ffc8862b",
+                "lily": "cec35719",
+                "maria": "bbf8e803",
+                "nia": "e6231767",
+                "hana": "ed87431a",
+                "jayden": "672be390",
+                "stefan": "35cd52c0",
+                "tae": "6c21ac3e",
+                "felix": "83711427",
+                "malik": "94950cff",
+                "liam": "734451fd",
+                "joon": "48b5553f",
+                "erik": "e572fd1d",
+                "ryu": "e1c17f9c",
+            }
+
+    @classmethod
+    def from_env(cls) -> "UGCConfig":
+        return cls(
+            output_dir=os.getenv("UGC_OUTPUT_DIR", str(Path.home() / ".openclaw" / "workspace" / "ugc-output")),
+        )
+
+    def get_avatar_id(self, name_or_id: str) -> str:
+        """Get full avatar ID from name or partial ID."""
+        # Already a full UUID
+        if len(name_or_id) == 36 and "-" in name_or_id:
+            return name_or_id
+        # Short ID (8 chars)
+        if len(name_or_id) == 8 and name_or_id.isalnum():
+            return name_or_id
+        # Name lookup
+        return self.avatars.get(name_or_id.lower(), name_or_id)

bonanza_ugc-0.1.0/bonanza_ugc/generator.py

@@ -0,0 +1,387 @@
+"""UGC Generator — Generate AI UGC videos via Higgsfield Marketing Studio."""
+
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+import tempfile
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from .config import UGCConfig
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class UGCVideo:
+    """A generated UGC video."""
+    job_id: str = ""
+    status: str = "pending"
+    result_url: str = ""
+    local_path: str = ""
+    prompt: str = ""
+    mode: str = ""
+    avatar: str = ""
+    duration: int = 0
+    virality_score: int = 0
+    brain_activity: dict = field(default_factory=dict)
+    product_url: str = ""
+    product_id: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "job_id": self.job_id,
+            "status": self.status,
+            "result_url": self.result_url,
+            "local_path": self.local_path,
+            "prompt": self.prompt,
+            "mode": self.mode,
+            "avatar": self.avatar,
+            "duration": self.duration,
+            "virality_score": self.virality_score,
+            "product_url": self.product_url,
+            "product_id": self.product_id,
+        }
+
+
+@dataclass
+class UGCScore:
+    """Virality score from Brain Activity."""
+    job_id: str = ""
+    overall_score: int = 0
+    hook_score: int = 0
+    viral_potential: int = 0
+    brain_engagement: int = 0
+    sustain_score: int = 0
+    peak_second: int = 0
+    regions: dict = field(default_factory=dict)
+    recommendations: list = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "overall_score": self.overall_score,
+            "hook_score": self.hook_score,
+            "viral_potential": self.viral_potential,
+            "brain_engagement": self.brain_engagement,
+            "sustain_score": self.sustain_score,
+            "peak_second": self.peak_second,
+            "regions": self.regions,
+            "recommendations": self.recommendations,
+        }
+
+
+class UGCGenerator:
+    """Generate UGC videos using Higgsfield Marketing Studio.
+
+    Usage:
+        from bonanza_ugc import UGCGenerator, UGCConfig
+
+        gen = UGCGenerator()
+        video = gen.generate(
+            prompt="Dutch woman shows off her silver chain necklace...",
+            avatar="mei",
+            mode="ugc",
+            duration=15,
+        )
+        print(f"Video URL: {video.result_url}")
+        print(f"Virality: {video.virality_score}/100")
+
+        # Score a video
+        score = gen.score(video)
+        print(f"Hook: {score.hook_score}/100")
+    """
+
+    # Marketing Studio modes
+    MODES = [
+        "ugc", "ugc_how_to", "ugc_unboxing", "product_showcase",
+        "product_review", "tv_spot", "wild_card",
+        "ugc_virtual_try_on", "virtual_try_on",
+    ]
+
+    # Product-specific prompt templates
+    PROMPT_TEMPLATES = {
+        "silverjstore": {
+            "ugc": "A stylish young {gender} enthusiastically shows off their beautiful 925 sterling silver {product_name}. They hold it up to the light, talking about how it sparkles and makes them feel elegant and confident. They mention it's affordable luxury from SilverJStore with free shipping across the Netherlands. Natural lighting, warm tone, authentic UGC style.",
+            "ugc_unboxing": "Excited {gender} unboxes a package from SilverJStore, revealing a stunning 925 sterling silver {product_name}. They react to the luxury packaging, show the hallmark, and try it on. Authentic unboxing experience, warm lighting.",
+            "product_showcase": "Close-up product showcase of a 925 sterling silver {product_name} from SilverJStore. The piece catches the light beautifully, showing the craftsmanship and hallmark. Professional but approachable, 9:16 vertical format.",
+            "product_review": "A {gender} gives an honest review of their 925 sterling silver {product_name} from SilverJStore. They show the quality, the hallmark, mention the free shipping and 14-day return policy. Authentic, trustworthy review style.",
+        },
+    }
+
+    def __init__(self, config: Optional[UGCConfig] = None):
+        self.config = config or UGCConfig()
+        self.output_dir = Path(self.config.output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def _higgsfield(self, *args: str, json_output: bool = True) -> dict | list:
+        """Run a higgsfield CLI command and return parsed JSON output."""
+        cmd = ["higgsfield"] + list(args)
+        if json_output:
+            cmd.append("--json")
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
+        if result.returncode != 0:
+            logger.error(f"Higgsfield error: {result.stderr}")
+            raise RuntimeError(f"Higgsfield command failed: {result.stderr}")
+        if json_output and result.stdout.strip():
+            return json.loads(result.stdout)
+        return {"raw": result.stdout}
+
+    def _higgsfield_wait(self, job_id: str, timeout: int = 600, interval: int = 15) -> dict:
+        """Wait for a Higgsfield job to complete."""
+        start = time.time()
+        while time.time() - start < timeout:
+            result = self._higgsfield("generate", "get", job_id)
+            status = result.get("status", "unknown")
+            if status == "completed":
+                return result
+            elif status == "failed":
+                raise RuntimeError(f"Job {job_id} failed: {result.get('fail_reason', 'unknown')}")
+            logger.info(f"Job {job_id}: {status}...")
+            time.sleep(interval)
+        raise TimeoutError(f"Job {job_id} timed out after {timeout}s")
+
+    def generate(
+        self,
+        prompt: str,
+        avatar: str = "mei",
+        mode: str = "ugc",
+        duration: int = 15,
+        resolution: str = "720p",
+        aspect_ratio: str = "9:16",
+        generate_audio: bool = True,
+        product_url: str = "",
+        wait: bool = True,
+        timeout: int = 600,
+    ) -> UGCVideo:
+        """Generate a UGC video.
+
+        Args:
+            prompt: Video prompt describing the scene
+            avatar: Avatar name (e.g., "mei", "jayden") or ID
+            mode: Marketing Studio mode (ugc, ugc_how_to, etc.)
+            duration: Video duration in seconds (10, 15)
+            resolution: Video resolution (720p, 1080p)
+            aspect_ratio: Video aspect ratio (9:16, 16:9, 1:1)
+            generate_audio: Whether to generate speech audio
+            product_url: Product URL to fetch and include
+            wait: Whether to wait for completion
+            timeout: Max wait time in seconds
+
+        Returns:
+            UGCVideo with result_url if wait=True
+        """
+        avatar_id = self.config.get_avatar_id(avatar)
+
+        # Build command
+        cmd_args = [
+            "generate", "create", "marketing_studio_video",
+            "--prompt", prompt,
+            "--mode", mode,
+            "--duration", str(duration),
+            "--resolution", resolution,
+            "--aspect-ratio", aspect_ratio,
+        ]
+
+        if generate_audio:
+            cmd_args.extend(["--generate-audio", "true"])
+
+        # Avatar
+        avatar_data = [{"id": avatar_id, "type": "preset"}]
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            json.dump(avatar_data, f)
+            avatar_file = f.name
+        cmd_args.extend(["--avatars", f"@{avatar_file}"])
+
+        # Product
+        product_id = ""
+        if product_url:
+            try:
+                result = self._higgsfield(
+                    "marketing-studio", "products", "fetch",
+                    "--url", product_url, "--json"
+                )
+                product_id = result.get("id", "")
+                if product_id:
+                    product_data = [product_id]
+                    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+                        json.dump(product_data, f)
+                    cmd_args.extend(["--product_ids", f"@{f.name}"])
+            except Exception as e:
+                logger.warning(f"Failed to fetch product: {e}")
+
+        # Create job
+        if not wait:
+            cmd_args.append("--json")
+            result = self._higgsfield(*cmd_args[2:])  # skip "higgsfield" prefix
+            job_ids = result if isinstance(result, list) else [result]
+            video = UGCVideo(
+                job_id=job_ids[0] if job_ids else "",
+                status="submitted",
+                prompt=prompt,
+                mode=mode,
+                avatar=avatar,
+                duration=duration,
+                product_url=product_url,
+                product_id=product_id,
+            )
+            return video
+
+        # Wait for completion
+        cmd_args.extend(["--wait", "--wait-timeout", f"{timeout}s"])
+        try:
+            result = self._higgsfield(*cmd_args[2:])
+        except Exception as e:
+            logger.error(f"Video generation failed: {e}")
+            # Try to get job ID from error
+            return UGCVideo(status="failed", prompt=prompt)
+
+        video = UGCVideo(
+            job_id=result.get("id", ""),
+            status=result.get("status", "unknown"),
+            result_url=result.get("result_url", ""),
+            prompt=prompt,
+            mode=mode,
+            avatar=avatar,
+            duration=duration,
+            product_url=product_url,
+            product_id=product_id,
+        )
+
+        # Download if we have a URL
+        if video.result_url:
+            local_path = self.download(video.result_url, f"{mode}_{avatar}_{int(time.time())}.mp4")
+            video.local_path = str(local_path)
+
+        # Auto-score virality
+        if self.config.score_virality and video.result_url:
+            try:
+                score = self.score(video)
+                video.virality_score = score.overall_score
+                video.brain_activity = score.to_dict()
+            except Exception as e:
+                logger.warning(f"Virality scoring failed: {e}")
+
+        return video
+
+    def score(self, video: UGCVideo | str, wait: bool = True) -> UGCScore:
+        """Score a video's virality using Brain Activity.
+
+        Args:
+            video: UGCVideo object, video URL, or local file path
+            wait: Whether to wait for completion
+
+        Returns:
+            UGCScore with virality metrics
+        """
+        video_path = ""
+        if isinstance(video, UGCVideo):
+            video_path = video.local_path or video.result_url
+        else:
+            video_path = str(video)
+
+        if not video_path:
+            raise ValueError("No video path available")
+
+        cmd_args = ["generate", "create", "brain_activity", "--video", video_path, "--json"]
+
+        if wait:
+            cmd_args.extend(["--wait", "--wait-timeout", "300s"])
+
+        result = self._higgsfield(*cmd_args[2:])
+
+        if wait:
+            analysis = result.get("params", {}).get("analysis", {})
+            scores = analysis.get("scores", {})
+            summary = analysis.get("summary", {})
+            regions = analysis.get("regions", [])
+
+            # Build recommendations
+            recommendations = []
+            hook = scores.get("hook_score", 0)
+            if hook < 50:
+                recommendations.append(f"Hook score ({hook}/100) is weak. Start with the product visible in the first second.")
+            overall = scores.get("overall_score", 0)
+            if overall < 40:
+                recommendations.append("Overall score below 40. Try different hooks, angles, or avatar expressions.")
+            sustain = scores.get("sustain", 0)
+            if sustain < 70:
+                recommendations.append("Sustain is low. Add variety — close-ups, different angles, text overlays.")
+
+            return UGCScore(
+                job_id=result.get("id", ""),
+                overall_score=scores.get("overall_score", 0),
+                hook_score=scores.get("hook_score", 0),
+                viral_potential=scores.get("viral_potential", 0),
+                brain_engagement=scores.get("brain_engagement", 0),
+                sustain_score=scores.get("sustain", 0),
+                peak_second=scores.get("peak_second", 0),
+                regions={r.get("id", ""): r for r in regions},
+                recommendations=recommendations,
+            )
+        else:
+            job_ids = result if isinstance(result, list) else [result]
+            return UGCScore(job_id=job_ids[0] if job_ids else "", status="submitted")
+
+    def download(self, url: str, filename: str = "") -> Path:
+        """Download a video from URL to local storage."""
+        if not filename:
+            filename = f"ugc_{int(time.time())}.mp4"
+        local_path = self.output_dir / filename
+
+        import urllib.request
+        urllib.request.urlretrieve(url, str(local_path))
+        logger.info(f"Downloaded: {local_path}")
+        return local_path
+
+    def list_avatars(self) -> list[dict]:
+        """List all available preset avatars."""
+        try:
+            return self._higgsfield("marketing-studio", "avatars", "list")
+        except Exception:
+            return []
+
+    def list_products(self) -> list[dict]:
+        """List all imported products."""
+        try:
+            return self._higgsfield("marketing-studio", "products", "list")
+        except Exception:
+            return []
+
+    def generate_from_template(
+        self,
+        template: str = "silverjstore",
+        product_name: str = "",
+        avatar: str = "mei",
+        mode: str = "ugc",
+        gender: str = "woman",
+        **kwargs,
+    ) -> UGCVideo:
+        """Generate a UGC video from a prompt template.
+
+        Args:
+            template: Template name (currently: "silverjstore")
+            product_name: Product name to include in prompt
+            avatar: Avatar name or ID
+            mode: Marketing Studio mode
+            gender: Gender for prompt template
+            **kwargs: Additional args passed to generate()
+
+        Returns:
+            UGCVideo
+        """
+        templates = self.PROMPT_TEMPLATES.get(template, {})
+        prompt_template = templates.get(mode, templates.get("ugc", ""))
+
+        if not prompt_template:
+            raise ValueError(f"No template found for '{template}' mode '{mode}'")
+
+        prompt = prompt_template.format(
+            product_name=product_name or "silver jewelry",
+            gender=gender,
+        )
+
+        return self.generate(prompt=prompt, avatar=avatar, mode=mode, **kwargs)

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

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: bonanza-ugc
+Version: 0.1.0
+Summary: AI-generated UGC videos via Higgsfield Marketing Studio
+Author: Bonanza Labs
+License-Expression: MIT
+Keywords: ugc,ai,video,higgsfield,marketing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+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
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Bonanza UGC
+
+AI-generated UGC videos via Higgsfield Marketing Studio.
+
+## Install
+
+```bash
+pip install bonanza-ugc
+```
+
+## Quick Start
+
+```python
+from bonanza_ugc import UGCGenerator, UGCConfig
+
+gen = UGCGenerator()
+video = gen.generate(
+    prompt="A stylish young woman shows off her silver chain necklace...",
+    avatar="mei",
+    mode="ugc",
+    duration=15,
+)
+print(f"Video URL: {video.result_url}")
+print(f"Virality: {video.virality_score}/100")
+```
+
+## CLI
+
+```bash
+# Generate a video
+ugc generate --prompt "..." --avatar mei --mode ugc
+
+# Use a template
+ugc generate --template silverjstore --product "Venetian Chain" --avatar mei
+
+# Score virality
+ugc score <video_path_or_url>
+
+# List avatars
+ugc avatars
+
+# Batch generate
+ugc batch --leads leads.json --mode ugc
+```
+
+## Features
+
+- 🎬 Generate UGC videos with AI avatars
+- 📊 Score video virality with Brain Activity analysis
+- 🎯 Prompt templates for product categories
+- 📦 Batch generation support
+- 🔄 Product URL fetching and integration
+
+## License
+
+MIT

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

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+bonanza_ugc/__init__.py
+bonanza_ugc/cli.py
+bonanza_ugc/config.py
+bonanza_ugc/generator.py
+bonanza_ugc.egg-info/PKG-INFO
+bonanza_ugc.egg-info/SOURCES.txt
+bonanza_ugc.egg-info/dependency_links.txt
+bonanza_ugc.egg-info/entry_points.txt
+bonanza_ugc.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1 @@
+bonanza_ugc

bonanza_ugc-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bonanza-ugc"
+version = "0.1.0"
+description = "AI-generated UGC videos via Higgsfield Marketing Studio"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Bonanza Labs" },
+]
+keywords = ["ugc", "ai", "video", "higgsfield", "marketing"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Multimedia :: Video",
+]
+dependencies = []
+
+[project.scripts]
+ugc = "bonanza_ugc.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["bonanza_ugc*"]

bonanza_ugc-0.1.0/setup.cfg

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