from openai import OpenAI
# Initialiser le client
client = OpenAI(
api_key="<LLMOXY_API_KEY>", # Entrez votre jeton
base_url="https://llmoxy.com/v1" # Point d'accès API
)
# Envoyer la requête
response = client.chat.completions.create(
model="gpt-5.4",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Hello!"}
],
stream=False
)
print(response.choices[0].message.content)
import cv2
import base64
import requests
import os
import math
class VideoAnalyzer:
def __init__(self, video_path):
self.video_path = video_path
if not os.path.exists(video_path):
raise FileNotFoundError(f"❌ Fichier vidéo introuvable : {video_path}")
def get_metadata(self):
"""1. Obtenir les paramètres techniques de base de la vidéo"""
cap = cv2.VideoCapture(self.video_path)
if not cap.isOpened():
return None
fps = cap.get(cv2.CAP_PROP_FPS)
frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
duration = frame_count / fps if fps > 0 else 0
cap.release()
return {
"width": width,
"height": height,
"fps": round(fps, 2),
"frame_count": frame_count,
"duration_sec": round(duration, 2),
"file_size_mb": round(os.path.getsize(self.video_path) / (1024 * 1024), 2)
}
def extract_keyframes(self, max_frames=5, target_width=512):
"""2. Extraire les images clés pour l'analyse IA"""
print("📸 Extraction des images clés en cours...")
cap = cv2.VideoCapture(self.video_path)
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
if total_frames == 0:
return []
interval = max(1, total_frames // max_frames)
base64_frames = []
for i in range(0, total_frames, interval):
if len(base64_frames) >= max_frames:
break
cap.set(cv2.CAP_PROP_POS_FRAMES, i)
ret, frame = cap.read()
if ret:
h, w, _ = frame.shape
aspect_ratio = h / w
new_height = int(target_width * aspect_ratio)
resized_frame = cv2.resize(frame, (target_width, new_height))
_, buffer = cv2.imencode('.jpg', resized_frame)
base64_str = base64.b64encode(buffer).decode('utf-8')
base64_frames.append(base64_str)
cap.release()
print(f"✅ Extraction réussie de {len(base64_frames)} images clés")
return base64_frames
def analyze_content_with_ai(self, api_key, base64_frames):
"""3. Appeler le grand modèle de vision pour analyser le contenu vidéo"""
print("🧠 Demande d'analyse du contenu vidéo par l'IA en cours...")
url = "https://llmoxy.com/v1/chat/completions"
content_payload = [
{"type": "text", "text": "Voici plusieurs frames extraites chronologiquement de la même vidéo. Veuillez décrire en détail ce qui s'est passé dans cette vidéo ? Y compris les scènes, les actions des personnages, l'atmosphère et les événements principaux."}
]
for b64 in base64_frames:
content_payload.append({
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{b64}",
"detail": "low"
}
})
payload = {
"model": "gpt-5.4",
"messages": [{"role": "user", "content": content_payload}],
"max_tokens": 1000,
"stream": True
}
try:
response = requests.post(url, headers={"Authorization": f"Bearer {api_key}"}, json=payload, stream=True)
print("\n📝 Rapport d'analyse vidéo :\n" + "="*30)
full_analysis = ""
for line in response.iter_lines():
if line:
decoded = line.decode('utf-8')
if decoded.startswith('data: ') and decoded != 'data: [DONE]':
try:
chunk = decoded[6:]
import json
delta = json.loads(chunk)['choices'][0]['delta'].get('content', '')
print(delta, end='', flush=True)
full_analysis += delta
except:
pass
print("\n" + "="*30)
return full_analysis
except Exception as e:
print(f"❌ Analyse échouée : {e}")
return None
# Exemple d'utilisation
if __name__ == "__main__":
video_file = r"Chemin de votre fichier vidéo.mp4" # Remplacez par le chemin de votre fichier vidéo
my_api_key = "<LLMOXY_API_KEY>" # Remplacez par votre clé API
if not os.path.exists(video_file):
print(f"⚠️ {video_file} non trouvé, veuillez préparer un fichier vidéo d'abord.")
else:
analyzer = VideoAnalyzer(video_file)
meta = analyzer.get_metadata()
print(f"\n📊 Métadonnées vidéo : {meta}")
frames = analyzer.extract_keyframes(max_frames=5)
if frames:
analyzer.analyze_content_with_ai(my_api_key, frames)
import requests, json, base64
API_URL = "https://llmoxy.com/v1/chat/completions"
API_KEY = "Bearer <LLMOXY_API_KEY>" # Remplacez par votre clé API
def analyze_image(img_path):
"""Analyser l'image"""
with open(img_path, "rb") as f:
img_base64 = base64.b64encode(f.read()).decode()
payload = {
"model": "gpt-5.4", # Nom du modèle
"messages": [{
"role": "user",
"content": [
{"type": "text", "text": "Veuillez décrire cette image"},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{img_base64}"}
}
]
}],
"stream": True
}
headers = {
"Content-Type": "application/json",
"Authorization": API_KEY
}
response = requests.post(API_URL, json=payload, headers=headers, stream=True)
for line in response.iter_lines():
if line:
line = line.decode('utf-8').replace('data: ', '')
if line.strip() == '[DONE]': break
try:
data = json.loads(line)
if content := data['choices'][0]['delta'].get('content'):
print(content, end="", flush=True)
except:
continue
print()
# Exemple d'utilisation
analyze_image(r"Chemin de votre image.jpg") # Remplacez par le chemin réel de l'image
import requests
import time
import json
import os
def generate_video_stream_with_retry(prompt, api_key, max_retries=3):
"""Fonction d'obtention d'instructions de génération vidéo en streaming avec mécanisme de réessai"""
base_url = "https://llmoxy.com/v1/chat/completions"
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "veo_3_1",
"messages": [
{
"role": "user",
"content": f"Veuillez m'aider à générer une vidéo, la description est : {prompt}. Veuillez me dire les étapes de génération de la vidéo ou fournir directement le lien de la vidéo."
}
],
"max_tokens": 5000,
"temperature": 0.7,
"stream": True
}
for attempt in range(max_retries):
print(f"\n🔄 Tentative {attempt + 1}/{max_retries}...")
full_content = ""
try:
response = requests.post(base_url, headers=headers, json=payload, timeout=120, stream=True)
if response.status_code != 200:
print(f"❌ Requête échouée, code de statut : {response.status_code}")
if 500 <= response.status_code < 600:
print("⏳ Erreur serveur, attente avant réessai...")
time.sleep(5)
continue
else:
return None
print("✅ Connexion réussie, début de réception du flux de données...\n")
print("-" * 30)
for line in response.iter_lines():
if line:
decoded_line = line.decode('utf-8')
if decoded_line.startswith('data: '):
data_str = decoded_line[6:]
if data_str.strip() == '[DONE]':
print("\n" + "-" * 30)
print("\n✅ Fin du streaming")
break
try:
data_json = json.loads(data_str)
delta = data_json['choices'][0]['delta'].get('content', '')
if delta:
print(delta, end='', flush=True)
full_content += delta
except json.JSONDecodeError:
continue
if full_content:
with open("ai_response.txt", "w", encoding="utf-8") as f:
f.write(full_content)
print(f"📝 Réponse complète enregistrée dans ai_response.txt")
return full_content
else:
print("⚠️ Aucun contenu reçu")
return None
except requests.exceptions.Timeout:
print("⏰ Délai de connexion dépassé")
time.sleep(5)
continue
except Exception as e:
print(f"❌ Erreur inconnue : {e}")
return None
print(f"😞 Échec persistant après {max_retries} tentatives")
return None
# Exemple d'utilisation
if __name__ == "__main__":
my_api_key = "<LLMOXY_API_KEY>" # Remplacez par votre clé API
result = generate_video_stream_with_retry(
prompt="Un chien surfant en mer",
api_key=my_api_key,
max_retries=5
)
if result:
print("\n🎬 Tâche terminée")
else:
print("\n❌ Tâche échouée")
import requests
import json
import os
import re
from datetime import datetime
from pathlib import Path
from typing import Optional, Dict, Any, List
from urllib.parse import urlparse
class ImageGenerator:
def __init__(self):
self.api_key = "<LLMOXY_API_KEY>" # Remplacez par votre clé API
self.api_url = "https://llmoxy.com/v1/chat/completions"
self.model = "nano-banana"
self.headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
def generate_image(self, prompt: str, save_dir: str = "./generated_images") -> Dict[str, Any]:
"""Générer une image et retourner les liens d'image"""
Path(save_dir).mkdir(parents=True, exist_ok=True)
payload = {
"model": self.model,
"messages": [{"role": "user", "content": f"Generate an image based on this prompt: {prompt}"}],
"max_tokens": 1000
}
print(f"Génération d'image en cours...")
print(f"Prompt : {prompt}")
try:
response = requests.post(self.api_url, headers=self.headers, json=payload, timeout=600)
if response.status_code == 200:
return self._process_response(response, prompt, save_dir)
else:
print(f"Échec de la requête API : {response.status_code}")
return {"success": False, "error": f"HTTP {response.status_code}", "image_links": []}
except requests.exceptions.RequestException as e:
print(f"Exception de requête : {e}")
return {"success": False, "error": str(e), "image_links": []}
def _process_response(self, response, prompt, save_dir):
result = {"success": False, "image_links": [], "content": "", "error": None}
try:
response_data = response.json()
if "choices" in response_data and response_data["choices"]:
content = response_data["choices"][0]["message"]["content"]
result["content"] = content
print(f"Contenu de la réponse API : {content}")
# Extraire les liens d'image
url_patterns = [
r'https?://[^\s]+?\.(?:jpg|jpeg|png|gif|bmp|webp)',
r'https?://[^\s]+?/image/[^\s]+',
]
found_links = []
for pattern in url_patterns:
matches = re.findall(pattern, content, re.IGNORECASE)
found_links.extend(matches)
if found_links:
result["success"] = True
result["image_links"] = found_links
print(f"Liens d'image trouvés : {found_links}")
else:
result["success"] = True
result["note"] = "L'API a retourné une description textuelle, aucun lien d'image trouvé"
except Exception as e:
result["error"] = f"Échec du traitement de la réponse : {e}"
return result
def main():
print("🎨 Script de génération d'images")
print("-" * 50)
generator = ImageGenerator()
prompt = "Un chiot mignon jouant dans le jardin" # Modifiez le contenu du prompt ici
result = generator.generate_image(prompt=prompt, save_dir="./test_images")
print("\n" + "=" * 50)
if result.get("success", False):
print("✅ Requête réussie !")
if result.get("image_links"):
print(f"\n📷 {len(result['image_links'])} liens d'image trouvés :")
for i, link in enumerate(result["image_links"], 1):
print(f" {i}. {link}")
else:
print(f"❌ Génération échouée : {result.get('error', 'Erreur inconnue')}")
if __name__ == "__main__":
main()
Reconnaissance d'image Si vous avez besoin d'envoyer des images, veuillez utiliser le modèle gpt-5.4 et référez-vous au format standard OpenAI Vision.