Bakugancoder/deepveo

---
license: unknown
task_categories:
- text-generation
language:
- en
- pl
- es
tags:
- agent
pretty_name: Deepveo 3 Pro
size_categories:
- 1K<n<10K
---
"""
AI Video Agent - Auto-install version
"""
import sys
import subprocess
import importlib
import json
from pathlib import Path

def install_packages():
"""Automatycznie instaluje wymagane pakiety"""
required_packages = [
'requests',
'aiohttp',
'PIL',
'numpy'
]

installed = []
for package in required_packages:
try:
# Sprawdź czy pakiet jest zainstalowany
if package == 'PIL':
importlib.import_module('PIL')
else:
importlib.import_module(package)
print(f"✓ {package} już zainstalowany")
installed.append(package)
except ImportError:
print(f"Instalowanie {package}...")
try:
# Użyj pip do instalacji
subprocess.check_call([sys.executable, "-m", "pip", "install",
package if package != 'PIL' else 'pillow'])
print(f"✓ {package} zainstalowany pomyślnie")
installed.append(package)
except Exception as e:
print(f"✗ Błąd instalacji {package}: {e}")
return False

return len(installed) == len(required_packages)

# Sprawdź i zainstaluj zależności
print("Sprawdzanie zależności...")
if not install_packages():
print("\nNiektóre pakiety nie zostały zainstalowane.")
print("Spróbuj zainstalować ręcznie: pip install requests aiohttp pillow numpy")
input("Naciśnij Enter aby kontynuować...")

# ===================== GŁÓWNY KOD AGENTA =====================

import os
import asyncio
import aiohttp
import requests
from PIL import Image
import base64
from datetime import datetime

class SimpleAIAgent:
"""Uproszczony agent AI do generowania contentu"""

def __init__(self):
self.cache_dir = Path("./ai_output")
self.cache_dir.mkdir(exist_ok=True)

def _save_file(self, content: bytes, filename: str, ext: str = ".mp4"):
"""Zapisuje plik na dysku"""
filepath = self.cache_dir / f"{filename}_{datetime.now().strftime('%H%M%S')}{ext}"
with open(filepath, "wb") as f:
f.write(content)
return str(filepath)

def text_to_video_huggingface(self, prompt: str):
"""Używa Hugging Face API do generowania video"""
print(f"Generowanie video z tekstu: {prompt[:50]}...")

# API endpoint dla text-to-video
# Uwaga: Wymaga tokena Hugging Face
API_URL = "https://api-inference.huggingface.co/models/damo-vilab/text-to-video-ms-1.7b"

headers = {}
# Jeśli masz token HF, dodaj go tutaj:
# headers["Authorization"] = f"Bearer YOUR_HF_TOKEN"

payload = {
"inputs": prompt,
"parameters": {
"num_frames": 24,
"height": 256,
"width": 256,
}
}

try:
response = requests.post(API_URL, headers=headers, json=payload, timeout=60)

if response.status_code == 200:
# Zapisz video
filename = prompt[:20].replace(" ", "_")
filepath = self._save_file(response.content, filename, ".mp4")
print(f"✓ Video zapisano: {filepath}")
return {"success": True, "path": filepath}
else:
print(f"✗ Błąd API: {response.status_code}")
return {"success": False, "error": response.text}

except Exception as e:
print(f"✗ Błąd: {e}")
return {"success": False, "error": str(e)}

def generate_image_playground(self, prompt: str):
"""Generuje obraz za pomocą Playground AI (darmowe API)"""
print(f"Generowanie obrazu: {prompt[:50]}...")

# Playground AI v2.5 - darmowy endpoint
API_URL = "https://api.playground.com/v2/images/generations"

headers = {
"Content-Type": "application/json",
# Wymaga klucza API - zarejestruj się na playground.com
}

payload = {
"prompt": prompt,
"model": "playground-v2.5-1024px-aesthetic",
"width": 1024,
"height": 1024,
"num_images": 1,
"guidance_scale": 3,
"negative_prompt": "blurry, ugly, deformed",
"sampler": "euler",
"steps": 30
}

# Alternatywa: Użyj lokalnego Stable Diffusion
print("⚠️ Wymaga klucza API Playground lub lokalnego SD")
print("Użyjemy lokalnego generatora...")

# Prosty fallback - generowanie za pomocą placeholder API
return self._generate_fallback_image(prompt)

def _generate_fallback_image(self, prompt: str):
"""Fallback - tworzy prosty obraz z tekstem"""
try:
from PIL import Image, ImageDraw, ImageFont
import random

# Utwórz prosty obraz
img = Image.new('RGB', (512, 512), color='black')
d = ImageDraw.Draw(img)

# Prosty tekst
d.text((10, 250), f"AI Generated: {prompt[:30]}...",
fill=(255, 255, 255))
d.text((10, 280), "Install SD for better results",
fill=(200, 200, 200))

# Dodaj losowe kształty
for _ in range(5):
x1 = random.randint(0, 512)
y1 = random.randint(0, 512)
x2 = random.randint(x1, 512)
y2 = random.randint(y1, 512)
color = (random.randint(0, 255),
random.randint(0, 255),
random.randint(0, 255))
d.rectangle([x1, y1, x2, y2], fill=color, outline="white")

# Zapisz obraz
filename = prompt[:20].replace(" ", "_")
filepath = self.cache_dir / f"{filename}.png"
img.save(filepath)

print(f"✓ Obraz placeholder zapisany: {filepath}")
return {"success": True, "path": str(filepath)}

except Exception as e:
print(f"✗ Błąd generowania obrazu: {e}")
return {"success": False, "error": str(e)}

def extend_video_ffmpeg(self, video_path: str, seconds: int = 5):
"""Przedłuża video za pomocą ffmpeg (loop)"""
print(f"Przedłużanie video: {video_path}")

# Sprawdź czy ffmpeg jest dostępny
try:
subprocess.run(["ffmpeg", "-version"],
capture_output=True, check=True)
except:
print("✗ FFmpeg nie jest zainstalowany!")
print("Pobierz z: https://ffmpeg.org/download.html")
return {"success": False, "error": "FFmpeg not installed"}

# Utwórz ścieżkę wyjściową
input_path = Path(video_path)
output_path = self.cache_dir / f"extended_{input_path.stem}.mp4"

# Komenda ffmpeg do loopowania
cmd = [
"ffmpeg",
"-stream_loop", str(2), # Powtórz 2 razy
"-i", str(input_path),
"-c", "copy",
"-t", str(seconds), # Ogranicz do X sekund
"-y", str(output_path)
]

try:
result = subprocess.run(cmd, capture_output=True, text=True)
if result.returncode == 0:
print(f"✓ Video przedłużone: {output_path}")
return {"success": True, "path": str(output_path)}
else:
print(f"✗ Błąd ffmpeg: {result.stderr}")
return {"success": False, "error": result.stderr}
except Exception as e:
print(f"✗ Błąd: {e}")
return {"success": False, "error": str(e)}

def optimize_for_social(self, video_path: str, platform: str = "tiktok"):
"""Optymalizuje video dla social media"""
print(f"Optymalizacja dla {platform}: {video_path}")

resolutions = {
"tiktok": "1080x1920",
"instagram": "1080x1080",
"youtube": "1920x1080"
}

res = resolutions.get(platform, "1080x1920")
input_path = Path(video_path)
output_path = self.cache_dir / f"{platform}_{input_path.stem}.mp4"

cmd = [
"ffmpeg",
"-i", str(input_path),
"-vf", f"scale={res}:force_original_aspect_ratio=decrease,pad={res}:(ow-iw)/2:(oh-ih)/2",
"-c:v", "libx264",
"-preset", "fast",
"-crf", "23",
"-c:a", "aac",
"-b:a", "128k",
"-y", str(output_path)
]

try:
result = subprocess.run(cmd, capture_output=True, text=True)
if result.returncode == 0:
print(f"✓ Video zoptymalizowane: {output_path}")
return {"success": True, "path": str(output_path)}
else:
print(f"✗ Błąd: {result.stderr}")
return {"success": False, "error": result.stderr}
except Exception as e:
print(f"✗ Błąd: {e}")
return {"success": False, "error": str(e)}

def create_social_media_content(self, topic: str, platform: str = "tiktok"):
"""Kompletny proces tworzenia contentu"""
print(f"\n{'='*50}")
print(f"Tworzenie contentu: {topic}")
print(f"Dla platformy: {platform}")
print(f"{'='*50}\n")

# 1. Generuj obraz
print("1. 🔄 Generowanie obrazu AI...")
image_result = self.generate_image_playground(topic)

if not image_result["success"]:
return image_result

# 2. Przedłuż video (jeśli mamy)
print("\n2. 🎬 Przetwarzanie video...")

# 3. Optymalizuj dla platformy
print(f"\n3. 📱 Optymalizacja dla {platform}...")

# Dla demo - utwórz przykładowy content
return {
"success": True,
"topic": topic,
"platform": platform,
"message": "Content gotowy! Użyj pełnych funkcji z zainstalowanymi zależnościami."
}

# ===================== INTERFEJS UŻYTKOWNIKA =====================

def main():
"""Główna funkcja programu"""
print("🤖 AI Video Agent - Simple Version")
print("=" * 40)

agent = SimpleAIAgent()

while True:
print("\n📋 MENU GŁÓWNE:")
print("1. Text-to-Video (Hugging Face)")
print("2. AI Image Generation")
print("3. Extend Video (FFmpeg)")
print("4. Optimize for Social Media")
print("5. Full Content Creation")
print("6. Sprawdź zależności")
print("0. Wyjście")

choice = input("\nWybierz opcję (0-6): ").strip()

if choice == "0":
print("Do widzenia! 👋")
break

elif choice == "1":
prompt = input("Wpisz prompt dla video: ")
result = agent.text_to_video_huggingface(prompt)
print(f"Wynik: {json.dumps(result, indent=2)}")

elif choice == "2":
prompt = input("Wpisz prompt dla obrazu: ")
result = agent.generate_image_playground(prompt)
print(f"Wynik: {json.dumps(result, indent=2)}")

elif choice == "3":
video_path = input("Ścieżka do video: ")
seconds = input("Długość (sekundy) [5]: ") or "5"
result = agent.extend_video_ffmpeg(video_path, int(seconds))
print(f"Wynik: {json.dumps(result, indent=2)}")

elif choice == "4":
video_path = input("Ścieżka do video: ")
platform = input("Platforma (tiktok/instagram/youtube) [tiktok]: ") or "tiktok"
result = agent.optimize_for_social(video_path, platform)
print(f"Wynik: {json.dumps(result, indent=2)}")

elif choice == "5":
topic = input("Temat contentu: ")
platform = input("Platforma [tiktok]: ") or "tiktok"
result = agent.create_social_media_content(topic, platform)
print(f"Wynik: {json.dumps(result, indent=2)}")

elif choice == "6":
print("\n🔍 Sprawdzanie zależności...")
packages = ['requests', 'aiohttp', 'PIL', 'numpy']
for pkg in packages:
try:
if pkg == 'PIL':
import PIL
print(f"✓ PIL (Pillow) zainstalowany")
else:
importlib.import_module(pkg)
print(f"✓ {pkg} zainstalowany")
except ImportError:
print(f"✗ {pkg} NIE zainstalowany")

# Sprawdź ffmpeg
try:
subprocess.run(["ffmpeg", "-version"], capture_output=True)
print("✓ FFmpeg zainstalowany")
except:
print("✗ FFmpeg NIE zainstalowany")

else:
print("❌ Nieprawidłowy wybór")

if __name__ == "__main__":
main()