500 lines
21 KiB
Python
500 lines
21 KiB
Python
"""
|
|
DashScope API service
|
|
"""
|
|
import base64
|
|
import json
|
|
import logging
|
|
from pathlib import Path
|
|
from typing import Optional, Dict, Any
|
|
from dashscope import MultiModalConversation
|
|
import dashscope
|
|
from app.config import Config
|
|
|
|
logger = logging.getLogger('videoSummary')
|
|
|
|
class DashScopeService:
|
|
"""DashScope API service wrapper"""
|
|
|
|
def __init__(self, config: Config):
|
|
"""
|
|
Initialize DashScope service
|
|
|
|
Args:
|
|
config: Application configuration
|
|
"""
|
|
self.config = config
|
|
self.api_key = config.dashscope_api_key
|
|
self.model = config.dashscope_model
|
|
self.fps = config.dashscope_fps
|
|
self._api_key_set = False
|
|
|
|
def _ensure_api_key(self):
|
|
"""
|
|
Ensure API key is set before making API calls
|
|
|
|
Raises:
|
|
ValueError: If API key is not configured
|
|
"""
|
|
if not self.api_key:
|
|
raise ValueError(
|
|
"DashScope API key is required for video analysis. "
|
|
"Please set 'dashscope.api_key' in config.yaml file. "
|
|
"You can obtain your API key from: https://dashscope.console.aliyun.com/"
|
|
)
|
|
|
|
if not self._api_key_set:
|
|
dashscope.api_key = self.api_key
|
|
self._api_key_set = True
|
|
|
|
def _log_request(self, method_name: str, request_data: Dict[str, Any]):
|
|
"""
|
|
Log complete request data for third-party API calls
|
|
|
|
Args:
|
|
method_name: Name of the calling method
|
|
request_data: Request data dictionary containing model, messages, api_key, etc.
|
|
"""
|
|
try:
|
|
# Create a copy for logging to avoid modifying original
|
|
log_data = request_data.copy()
|
|
|
|
# Handle Base64 encoded video data - only log summary for large data
|
|
if 'messages' in log_data:
|
|
messages_copy = []
|
|
for msg in log_data['messages']:
|
|
msg_copy = msg.copy() if isinstance(msg, dict) else msg
|
|
if isinstance(msg_copy, dict) and 'content' in msg_copy:
|
|
content_copy = []
|
|
for content_item in msg_copy['content']:
|
|
if isinstance(content_item, dict) and 'video' in content_item:
|
|
video_value = content_item['video']
|
|
# If it's a Base64 data URI, only log the prefix and size
|
|
if isinstance(video_value, str) and video_value.startswith('data:video'):
|
|
# Extract size info if available
|
|
size_info = ''
|
|
if 'encoded_size' in log_data:
|
|
size_info = f" (encoded size: {log_data['encoded_size']} bytes)"
|
|
content_copy.append({
|
|
'video': f"data:video/mp4;base64,[BASE64_DATA{size_info}]",
|
|
'fps': content_item.get('fps', 'N/A')
|
|
})
|
|
else:
|
|
content_copy.append(content_item)
|
|
else:
|
|
content_copy.append(content_item)
|
|
msg_copy['content'] = content_copy
|
|
messages_copy.append(msg_copy)
|
|
log_data['messages'] = messages_copy
|
|
|
|
# Log complete request at DEBUG level
|
|
logger.debug(f"DashScope API Request [{method_name}] - Complete Request Data:")
|
|
logger.debug(json.dumps(log_data, indent=2, ensure_ascii=False))
|
|
|
|
# Log summary at INFO level
|
|
video_count = log_data.get('video_count', 'N/A')
|
|
if video_count == 'N/A' and 'video_paths' in log_data:
|
|
video_paths = log_data.get('video_paths', [])
|
|
video_count = len(video_paths) if isinstance(video_paths, list) else 'N/A'
|
|
|
|
summary = {
|
|
'method': method_name,
|
|
'model': log_data.get('model', 'N/A'),
|
|
'api_key': log_data.get('api_key', 'N/A'),
|
|
'messages_count': len(log_data.get('messages', [])),
|
|
'fps': log_data.get('fps', 'N/A'),
|
|
'video_count': video_count
|
|
}
|
|
logger.info(f"DashScope API Request [{method_name}] - Summary: {json.dumps(summary, ensure_ascii=False)}")
|
|
except Exception as e:
|
|
logger.warning(f"Failed to log request data: {str(e)}")
|
|
|
|
def _log_response(self, method_name: str, response: Any):
|
|
"""
|
|
Log complete response data from third-party API calls
|
|
|
|
Args:
|
|
method_name: Name of the calling method
|
|
response: Response object from DashScope API
|
|
"""
|
|
try:
|
|
# Log complete response at DEBUG level
|
|
logger.debug(f"DashScope API Response [{method_name}] - Complete Response Data:")
|
|
|
|
response_data = {
|
|
'status_code': getattr(response, 'status_code', 'N/A'),
|
|
'message': getattr(response, 'message', 'N/A'),
|
|
'request_id': getattr(response, 'request_id', 'N/A'),
|
|
}
|
|
|
|
# Try to get response output if available
|
|
if hasattr(response, 'output'):
|
|
try:
|
|
output_dict = {
|
|
'choices': []
|
|
}
|
|
if hasattr(response.output, 'choices') and response.output.choices:
|
|
for choice in response.output.choices:
|
|
choice_dict = {}
|
|
if hasattr(choice, 'message'):
|
|
if hasattr(choice.message, 'content'):
|
|
content_list = []
|
|
for content_item in choice.message.content:
|
|
if isinstance(content_item, dict):
|
|
# For text content, include full text
|
|
if 'text' in content_item:
|
|
content_list.append({'text': content_item['text']})
|
|
else:
|
|
# For other content types, include type only
|
|
content_list.append({k: v for k, v in content_item.items() if k != 'video' or not isinstance(v, str) or len(v) < 100})
|
|
else:
|
|
content_list.append(str(content_item))
|
|
choice_dict['message'] = {'content': content_list}
|
|
output_dict['choices'].append(choice_dict)
|
|
response_data['output'] = output_dict
|
|
except Exception as e:
|
|
response_data['output'] = f"Error extracting output: {str(e)}"
|
|
|
|
logger.debug(json.dumps(response_data, indent=2, ensure_ascii=False))
|
|
|
|
# Log summary at INFO level
|
|
summary = {
|
|
'method': method_name,
|
|
'status_code': response_data['status_code'],
|
|
'message': response_data['message'],
|
|
'request_id': response_data['request_id']
|
|
}
|
|
logger.info(f"DashScope API Response [{method_name}] - Summary: {json.dumps(summary, ensure_ascii=False)}")
|
|
|
|
# Log error details at ERROR level if failed
|
|
if response_data['status_code'] != 200:
|
|
logger.error(f"DashScope API Error [{method_name}] - Status: {response_data['status_code']}, Message: {response_data['message']}")
|
|
except Exception as e:
|
|
logger.warning(f"Failed to log response data: {str(e)}")
|
|
|
|
def analyze_video(self, video_path: Path, prompt: str, fps: Optional[int] = None) -> Dict[str, Any]:
|
|
"""
|
|
Analyze video content using DashScope API
|
|
|
|
Args:
|
|
video_path: Path to video file
|
|
prompt: Analysis prompt
|
|
fps: Frames per second (overrides config if provided)
|
|
|
|
Returns:
|
|
API response dictionary
|
|
|
|
Raises:
|
|
Exception: If API call fails
|
|
"""
|
|
# Ensure API key is set
|
|
self._ensure_api_key()
|
|
|
|
if not video_path.exists():
|
|
raise FileNotFoundError(f"Video file not found: {video_path}")
|
|
|
|
# According to DashScope documentation for Linux/macOS Python SDK:
|
|
# local_path = "xxx/test.mp4" # absolute path string
|
|
# video_path = f"file://{local_path}"
|
|
# Example from official docs:
|
|
# local_path = "xxx/test.mp4"
|
|
# video_path = f"file://{local_path}"
|
|
absolute_path = video_path.absolute()
|
|
local_path = str(absolute_path)
|
|
video_path_for_api = f"file://{local_path}"
|
|
|
|
# Log for debugging
|
|
logger.info(f"Using video path (file:// format as per official docs): {video_path_for_api}")
|
|
|
|
# Use provided fps or default from config
|
|
fps_value = fps if fps is not None else self.fps
|
|
|
|
# Prepare messages according to DashScope official documentation format:
|
|
# {'role':'user', 'content': [{'video': video_path, "fps":2}, {'text': '...'}]}
|
|
|
|
messages = [
|
|
{
|
|
'role': 'user',
|
|
'content': [
|
|
{'video': video_path_for_api, 'fps': fps_value},
|
|
{'text': prompt}
|
|
]
|
|
}
|
|
]
|
|
|
|
# Call API
|
|
try:
|
|
# Prepare request data for logging
|
|
request_data = {
|
|
'model': self.model,
|
|
'api_key': self.api_key,
|
|
'messages': messages,
|
|
'fps': fps_value,
|
|
'video_path': video_path_for_api
|
|
}
|
|
|
|
# Log complete request
|
|
self._log_request('analyze_video', request_data)
|
|
|
|
response = MultiModalConversation.call(
|
|
model=self.model,
|
|
messages=messages
|
|
)
|
|
|
|
# Log complete response
|
|
self._log_response('analyze_video', response)
|
|
|
|
if response.status_code == 200:
|
|
# Extract text content from response
|
|
content = response.output.choices[0].message.content[0]["text"]
|
|
return {
|
|
'success': True,
|
|
'content': content,
|
|
'fps': fps_value
|
|
}
|
|
else:
|
|
# If file:// format fails, try Base64 encoding as fallback
|
|
# Note: Base64 encoding increases file size by ~33%, and API limit is 10MB for encoded video
|
|
logger.warning(f"File:// format failed, trying Base64 encoding. Error: {response.message}")
|
|
|
|
try:
|
|
file_size = video_path.stat().st_size
|
|
# Check if file is too large for Base64 encoding (10MB limit for encoded video)
|
|
if file_size > 7 * 1024 * 1024: # ~7MB raw = ~10MB encoded
|
|
logger.error(f"Video file too large for Base64 encoding: {file_size} bytes (limit: ~7MB raw)")
|
|
return {
|
|
'success': False,
|
|
'error': f"Video file too large for Base64 encoding. File size: {file_size / 1024 / 1024:.2f}MB, limit: ~7MB raw (~10MB encoded). Please use a smaller video file.",
|
|
'status_code': response.status_code
|
|
}
|
|
|
|
# Read file and encode to Base64
|
|
with open(video_path, 'rb') as f:
|
|
video_data = f.read()
|
|
video_base64 = base64.b64encode(video_data).decode('utf-8')
|
|
|
|
logger.info(f"Using Base64 encoding (file size: {file_size} bytes, encoded size: {len(video_base64)} bytes)")
|
|
|
|
# According to DashScope docs, Base64 format should be: base64 encoded string
|
|
# Try data URI format first
|
|
messages_base64 = [
|
|
{
|
|
'role': 'user',
|
|
'content': [
|
|
{'video': f"data:video/mp4;base64,{video_base64}", 'fps': fps_value},
|
|
{'text': prompt}
|
|
]
|
|
}
|
|
]
|
|
|
|
# Prepare request data for logging (Base64 encoding)
|
|
request_data_base64 = {
|
|
'model': self.model,
|
|
'api_key': self.api_key,
|
|
'messages': messages_base64,
|
|
'fps': fps_value,
|
|
'encoding': 'base64',
|
|
'file_size': file_size,
|
|
'encoded_size': len(video_base64)
|
|
}
|
|
|
|
# Log complete request (Base64 encoding)
|
|
self._log_request('analyze_video_base64', request_data_base64)
|
|
|
|
response = MultiModalConversation.call(
|
|
model=self.model,
|
|
messages=messages_base64
|
|
)
|
|
|
|
# Log complete response (Base64 encoding)
|
|
self._log_response('analyze_video_base64', response)
|
|
|
|
if response.status_code == 200:
|
|
content = response.output.choices[0].message.content[0]["text"]
|
|
return {
|
|
'success': True,
|
|
'content': content,
|
|
'fps': fps_value
|
|
}
|
|
else:
|
|
logger.error(f"DashScope API error (all formats including Base64 failed) - Status: {response.status_code}, Message: {response.message}")
|
|
return {
|
|
'success': False,
|
|
'error': f"API error: {response.message}",
|
|
'status_code': response.status_code
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Base64 encoding failed: {str(e)}")
|
|
return {
|
|
'success': False,
|
|
'error': f"All upload methods failed. Last error: {response.message}. Base64 encoding error: {str(e)}",
|
|
'status_code': response.status_code
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"DashScope API exception: {str(e)}, Path used: {video_path_for_api}")
|
|
return {
|
|
'success': False,
|
|
'error': str(e)
|
|
}
|
|
|
|
def summarize_video(self, video_path: Path, fps: Optional[int] = None) -> Dict[str, Any]:
|
|
"""
|
|
Generate video summary
|
|
|
|
Args:
|
|
video_path: Path to video file
|
|
fps: Frames per second (overrides config if provided)
|
|
|
|
Returns:
|
|
Summary result dictionary
|
|
"""
|
|
prompt = "请对这段视频进行总结，包括主要内容、关键场景和重要信息。"
|
|
return self.analyze_video(video_path, prompt, fps)
|
|
|
|
def compare_videos(self, video_paths: list[Path], fps: Optional[int] = None) -> Dict[str, Any]:
|
|
"""
|
|
Compare multiple videos
|
|
|
|
Args:
|
|
video_paths: List of video file paths
|
|
fps: Frames per second (overrides config if provided)
|
|
|
|
Returns:
|
|
Comparison result dictionary
|
|
"""
|
|
# Ensure API key is set
|
|
self._ensure_api_key()
|
|
|
|
if len(video_paths) < 2:
|
|
return {
|
|
'success': False,
|
|
'error': 'At least two videos are required for comparison'
|
|
}
|
|
|
|
# Validate all video files exist
|
|
for path in video_paths:
|
|
if not path.exists():
|
|
return {
|
|
'success': False,
|
|
'error': f"Video file not found: {path}"
|
|
}
|
|
|
|
# Convert paths - try direct absolute path strings first
|
|
video_paths_for_api = []
|
|
for path in video_paths:
|
|
absolute_path = path.absolute()
|
|
local_path = str(absolute_path)
|
|
video_paths_for_api.append(local_path)
|
|
|
|
fps_value = fps if fps is not None else self.fps
|
|
|
|
# Prepare messages with multiple videos using file:// URI format
|
|
content = []
|
|
for video_uri in video_paths_for_api:
|
|
content.append({'video': video_uri, 'fps': fps_value})
|
|
|
|
prompt = "请对比这些视频的内容，找出它们的相似之处和不同之处，并详细说明。"
|
|
content.append({'text': prompt})
|
|
|
|
messages = [
|
|
{
|
|
'role': 'user',
|
|
'content': content
|
|
}
|
|
]
|
|
|
|
# Call API
|
|
try:
|
|
# Prepare request data for logging
|
|
request_data = {
|
|
'model': self.model,
|
|
'api_key': self.api_key,
|
|
'messages': messages,
|
|
'fps': fps_value,
|
|
'video_paths': video_paths_for_api,
|
|
'video_count': len(video_paths_for_api)
|
|
}
|
|
|
|
# Log complete request
|
|
self._log_request('compare_videos', request_data)
|
|
|
|
response = MultiModalConversation.call(
|
|
model=self.model,
|
|
messages=messages
|
|
)
|
|
|
|
# Log complete response
|
|
self._log_response('compare_videos', response)
|
|
|
|
if response.status_code == 200:
|
|
content_text = response.output.choices[0].message.content[0]["text"]
|
|
return {
|
|
'success': True,
|
|
'content': content_text,
|
|
'fps': fps_value
|
|
}
|
|
else:
|
|
# If direct paths fail, try file:// format
|
|
logger.warning(f"Direct paths failed, trying file:// format. Error: {response.message}")
|
|
|
|
video_urls = []
|
|
for path in video_paths:
|
|
absolute_path = path.absolute()
|
|
local_path = str(absolute_path)
|
|
video_urls.append(f"file://{local_path}")
|
|
|
|
content_retry = []
|
|
for video_url in video_urls:
|
|
content_retry.append({'video': video_url, 'fps': fps_value})
|
|
content_retry.append({'text': prompt})
|
|
|
|
messages_retry = [
|
|
{
|
|
'role': 'user',
|
|
'content': content_retry
|
|
}
|
|
]
|
|
|
|
# Prepare request data for logging (retry with file:// format)
|
|
request_data_retry = {
|
|
'model': self.model,
|
|
'api_key': self.api_key,
|
|
'messages': messages_retry,
|
|
'fps': fps_value,
|
|
'video_paths': video_urls,
|
|
'video_count': len(video_urls),
|
|
'retry': True
|
|
}
|
|
|
|
# Log complete request (retry)
|
|
self._log_request('compare_videos_retry', request_data_retry)
|
|
|
|
response = MultiModalConversation.call(
|
|
model=self.model,
|
|
messages=messages_retry
|
|
)
|
|
|
|
# Log complete response (retry)
|
|
self._log_response('compare_videos_retry', response)
|
|
|
|
if response.status_code == 200:
|
|
content_text = response.output.choices[0].message.content[0]["text"]
|
|
return {
|
|
'success': True,
|
|
'content': content_text,
|
|
'fps': fps_value
|
|
}
|
|
else:
|
|
logger.error(f"DashScope API error (both attempts failed) - Status: {response.status_code}, Message: {response.message}")
|
|
return {
|
|
'success': False,
|
|
'error': f"API error: {response.message}",
|
|
'status_code': response.status_code
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"DashScope API exception (compare): {str(e)}")
|
|
return {
|
|
'success': False,
|
|
'error': str(e)
|
|
}
|
|
|