# SDK Python

> Используйте SDK Python OpenAI для вызова Chat Completions через LLMoxy, с примером мультимодального анализа с извлечением кадров видео.

```python
from openai import OpenAI

# Инициализировать клиента
client = OpenAI(
    api_key="<LLMOXY_API_KEY>",              # Введите ваш токен
    base_url="https://llmoxy.com/v1" # Точка доступа API
)

# Отправить запрос
response = client.chat.completions.create(
    model="grok-4.7",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"}
    ],
    stream=False
)

print(response.choices[0].message.content)
```

```python
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"❌ Видеофайл не найден: {video_path}")
        
    def get_metadata(self):
        """1. Получить базовые технические параметры видео"""
        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. Извлечь ключевые кадры для ИИ-анализа"""
        print("📸 Извлечение ключевых кадров...")
        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"✅ Успешно извлечено {len(base64_frames)} ключевых кадров")
        return base64_frames

    def analyze_content_with_ai(self, api_key, base64_frames):
        """3. Вызвать визуальную модель для анализа содержимого видео"""
        print("🧠 Запрос ИИ-анализа содержимого видео...")
        
        url = "https://llmoxy.com/v1/chat/completions"
        
        content_payload = [
            {"type": "text", "text": "Это несколько кадров, извлеченных в хронологическом порядке из одного видео. Пожалуйста, подробно опишите, что произошло в этом видео? Включая сцены, действия персонажей, атмосферу и основные события."}
        ]
        
        for b64 in base64_frames:
            content_payload.append({
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{b64}",
                    "detail": "low"
                }
            })

        payload = {
            "model": "grok-4.7", 
            "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📝 Отчет об анализе видео:\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"❌ Анализ не удался: {e}")
            return None

# Пример использования
if __name__ == "__main__":
    video_file = r"Путь к вашему видеофайлу.mp4"  # Замените на путь к вашему видеофайлу
    my_api_key = "<LLMOXY_API_KEY>"  # Замените на ваш ключ API
    
    if not os.path.exists(video_file):
        print(f"⚠️ {video_file} не найден, пожалуйста, сначала подготовьте видеофайл.")
    else:
        analyzer = VideoAnalyzer(video_file)
        meta = analyzer.get_metadata()
        print(f"\n📊 Метаданные видео: {meta}")
        frames = analyzer.extract_keyframes(max_frames=5)
        if frames:
            analyzer.analyze_content_with_ai(my_api_key, frames)
```

```python
import requests, json, base64

API_URL = "https://llmoxy.com/v1/chat/completions"
API_KEY = "Bearer <LLMOXY_API_KEY>"  # Замените на ваш ключ API

def analyze_image(img_path):
    """Анализировать изображение"""
    with open(img_path, "rb") as f:
        img_base64 = base64.b64encode(f.read()).decode()
    
    payload = {
        "model": "grok-4.7",  # Название модели
        "messages": [{
            "role": "user",
            "content": [
                {"type": "text", "text": "Пожалуйста, опишите это изображение"},
                {
                    "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()

# Пример использования
analyze_image(r"Путь к вашему изображению.jpg")  # Замените на фактический путь к изображению
```

```python
import requests
import time
import json
import os

def generate_video_stream_with_retry(prompt, api_key, max_retries=3):
    """Функция получения инструкций по генерации видео в потоковом режиме с механизмом повторных попыток"""
    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"Пожалуйста, помогите мне сгенерировать видео, описание: {prompt}. Пожалуйста, расскажите шаги генерации видео или предоставьте прямую ссылку на видео."
            }
        ],
        "max_tokens": 5000,
        "temperature": 0.7,
        "stream": True
    }

    for attempt in range(max_retries):
        print(f"\n🔄 Попытка {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"❌ Запрос не удался, код состояния: {response.status_code}")
                if 500 <= response.status_code < 600:
                    print("⏳ Ошибка сервера, ожидание перед повторной попыткой...")
                    time.sleep(5)
                    continue
                else:
                    return None

            print("✅ Подключение успешно, начало приема потока данных...\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✅ Потоковая передача завершена")
                            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"📝 Полный ответ сохранен в ai_response.txt")
                return full_content
            else:
                print("⚠️ Контент не получен")
                return None

        except requests.exceptions.Timeout:
            print("⏰ Тайм-аут подключения")
            time.sleep(5)
            continue
        except Exception as e:
            print(f"❌ Неизвестная ошибка: {e}")
            return None

    print(f"😞 По-прежнему не удалось после {max_retries} попыток")
    return None

# Пример использования
if __name__ == "__main__":
    my_api_key = "<LLMOXY_API_KEY>"  # Замените на ваш ключ API
    
    result = generate_video_stream_with_retry(
        prompt="Собака, занимающаяся серфингом в море",
        api_key=my_api_key,
        max_retries=5
    )
    
    if result:
        print("\n🎬 Задача выполнена")
    else:
        print("\n❌ Задача не удалась")
```

```python
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>"  # Замените на ваш ключ 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]:
        """Сгенерировать изображение и вернуть ссылки на изображения"""
        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"Генерация изображения...")
        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"Ошибка запроса API: {response.status_code}")
                return {"success": False, "error": f"HTTP {response.status_code}", "image_links": []}
                
        except requests.exceptions.RequestException as e:
            print(f"Исключение запроса: {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"Содержимое ответа API: {content}")
                
                # Извлечь ссылки на изображения
                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"Найдены ссылки на изображения: {found_links}")
                else:
                    result["success"] = True
                    result["note"] = "API вернул текстовое описание, ссылки на изображения не найдены"
                    
        except Exception as e:
            result["error"] = f"Ошибка обработки ответа: {e}"
        
        return result

def main():
    print("🎨 Скрипт генерации изображений")
    print("-" * 50)
    
    generator = ImageGenerator()
    prompt = "Милый щенок, играющий в саду"  # Измените содержимое prompt здесь
    
    result = generator.generate_image(prompt=prompt, save_dir="./test_images")
    
    print("\n" + "=" * 50)
    if result.get("success", False):
        print("✅ Запрос успешен!")
        if result.get("image_links"):
            print(f"\n📷 Найдено {len(result['image_links'])} ссылок на изображения:")
            for i, link in enumerate(result["image_links"], 1):
                print(f"  {i}. {link}")
    else:
        print(f"❌ Генерация не удалась: {result.get('error', 'Неизвестная ошибка')}")

if __name__ == "__main__":
    main()
```

> **Распознавание изображений**
> Если вам нужно отправлять изображения, пожалуйста, используйте модель grok-4.7 и обратитесь к стандартному формату OpenAI Vision.

Это markdown-версия страницы https://ru.llmoxy.com/docs/code-tutorials/python-sdk.
