"""

if is_windows_path(draft_folder):

if os.name == 'nt': # 'nt' for Windows

draft_real_path = os.path.join(draft_folder, draft_id, "assets", asset_type, material_name)

else:

windows_drive, windows_path = re.match(r'([a-zA-Z]:)(.*)', draft_folder).groups()

parts = [p for p in windows_path.split('\\') if p]

draft_real_path = os.path.join(windows_drive, *parts, draft_id, "assets", asset_type, material_name)

draft_real_path = draft_real_path.replace('/', '\\')

else:

draft_real_path = os.path.join(draft_folder, draft_id, "assets", asset_type, material_name)

"""Background save draft to OSS"""

try:

# Get draft information from global cache

if draft_id not in DRAFT_CACHE:

task_status = {

"status": "failed",

"message": f"Draft {draft_id} does not exist in cache",

"progress": 0,

"completed_files": 0,

"total_files": 0,

"draft_url": ""

}

update_tasks_cache(task_id, task_status) # Use new cache management function

logger.error(f"Draft {draft_id} does not exist in cache, task {task_id} failed.")

return

script = DRAFT_CACHE[draft_id]

logger.info(f"Successfully retrieved draft {draft_id} from cache.")

# Update task status to processing

task_status = {

"status": "processing",

"message": "Preparing draft files",

"progress": 0,

"completed_files": 0,

"total_files": 0,

"draft_url": ""

}

update_tasks_cache(task_id, task_status) # Use new cache management function

logger.info(f"Task {task_id} status updated to 'processing': Preparing draft files.")

# Delete possibly existing draft_id folder

if os.path.exists(draft_id):

logger.warning(f"Deleting existing draft folder (current working directory): {draft_id}")

shutil.rmtree(draft_id)

logger.info(f"Starting to save draft: {draft_id}")

# Save draft

current_dir = os.path.dirname(os.path.abspath(__file__))

draft_folder_for_duplicate = draft.Draft_folder(current_dir)

# Choose different template directory based on configuration

template_dir = "template" if IS_CAPCUT_ENV else "template_jianying"

draft_folder_for_duplicate.duplicate_as_template(template_dir, draft_id)

# Update task status

update_task_field(task_id, "message", "Updating media file metadata")

update_task_field(task_id, "progress", 5)

logger.info(f"Task {task_id} progress 5%: Updating media file metadata.")

update_media_metadata(script, task_id)

download_tasks = []

audios = script.materials.audios

if audios:

for audio in audios:

remote_url = audio.remote_url

material_name = audio.material_name

# Use helper function to build path

if draft_folder:

audio.replace_path = build_asset_path(draft_folder, draft_id, "audio", material_name)

if not remote_url:

logger.warning(f"Audio file {material_name} has no remote_url, skipping download.")

continue

# Add audio download task

download_tasks.append({

'type': 'audio',

'func': download_file,

'args': (remote_url, os.path.join(current_dir, f"{draft_id}/assets/audio/{material_name}")),

'material': audio

})

# Collect video and image download tasks

videos = script.materials.videos

if videos:

for video in videos:

remote_url = video.remote_url

material_name = video.material_name

if video.material_type == 'photo':

# Use helper function to build path

if draft_folder:

video.replace_path = build_asset_path(draft_folder, draft_id, "image", material_name)

if not remote_url:

logger.warning(f"Image file {material_name} has no remote_url, skipping download.")

continue

# Add image download task

download_tasks.append({

'type': 'image',

'func': download_file,

'args': (remote_url, os.path.join(current_dir, f"{draft_id}/assets/image/{material_name}")),

'material': video

})

elif video.material_type == 'video':

# Use helper function to build path

if draft_folder:

video.replace_path = build_asset_path(draft_folder, draft_id, "video", material_name)

if not remote_url:

logger.warning(f"Video file {material_name} has no remote_url, skipping download.")

continue

# Add video download task

download_tasks.append({

'type': 'video',

'func': download_file,

'args': (remote_url, os.path.join(current_dir, f"{draft_id}/assets/video/{material_name}")),

'material': video

})

update_task_field(task_id, "message", f"Collected {len(download_tasks)} download tasks in total")

update_task_field(task_id, "progress", 10)

logger.info(f"Task {task_id} progress 10%: Collected {len(download_tasks)} download tasks in total.")

# Execute all download tasks concurrently

downloaded_paths = []

completed_files = 0

if download_tasks:

logger.info(f"Starting concurrent download of {len(download_tasks)} files...")

# Use thread pool for concurrent downloads, maximum concurrency of 16

with ThreadPoolExecutor(max_workers=16) as executor:

# Submit all download tasks

future_to_task = {

executor.submit(task['func'], *task['args']): task

for task in download_tasks

}

# Wait for all tasks to complete

for future in as_completed(future_to_task):

task = future_to_task[future]

try:

local_path = future.result()

downloaded_paths.append(local_path)

# Update task status - only update completed files count

completed_files += 1

update_task_field(task_id, "completed_files", completed_files)

task_status = get_task_status(task_id)

completed = task_status["completed_files"]

total = len(download_tasks)

update_task_field(task_id, "total_files", total)

# Download part accounts for 60% of the total progress

download_progress = 10 + int((completed / total) * 60)

update_task_field(task_id, "progress", download_progress)

update_task_field(task_id, "message", f"Downloaded {completed}/{total} files")

logger.info(f"Task {task_id}: Successfully downloaded {task['type']} file, progress {download_progress}.")

except Exception as e:

logger.error(f"Task {task_id}: Download {task['type']} file failed: {str(e)}", exc_info=True)

# Continue processing other files, don't interrupt the entire process

logger.info(f"Task {task_id}: Concurrent download completed, downloaded {len(downloaded_paths)} files in total.")

# Update task status - Start saving draft information

update_task_field(task_id, "progress", 70)

update_task_field(task_id, "message", "Saving draft information")

logger.info(f"Task {task_id} progress 70%: Saving draft information.")

script.dump(os.path.join(current_dir, f"{draft_id}/draft_info.json"))

logger.info(f"Draft information has been saved to {os.path.join(current_dir, draft_id)}/draft_info.json.")

draft_url = ""

# Only upload draft information when IS_UPLOAD_DRAFT is True

if IS_UPLOAD_DRAFT:

# Update task status - Start compressing draft

update_task_field(task_id, "progress", 80)

update_task_field(task_id, "message", "Compressing draft files")

logger.info(f"Task {task_id} progress 80%: Compressing draft files.")

# Compress the entire draft directory

zip_path = zip_draft(draft_id)

logger.info(f"Draft directory {os.path.join(current_dir, draft_id)} has been compressed to {zip_path}.")

# Update task status - Start uploading to OSS

update_task_field(task_id, "progress", 90)

update_task_field(task_id, "message", "Uploading to cloud storage")

logger.info(f"Task {task_id} progress 90%: Uploading to cloud storage.")

# Upload to OSS

draft_url = upload_to_oss(zip_path)

logger.info(f"Draft archive has been uploaded to OSS, URL: {draft_url}")

update_task_field(task_id, "draft_url", draft_url)

# Clean up temporary files

if os.path.exists(os.path.join(current_dir, draft_id)):

shutil.rmtree(os.path.join(current_dir, draft_id))

logger.info(f"Cleaned up temporary draft folder: {os.path.join(current_dir, draft_id)}")

# Update task status - Completed

update_task_field(task_id, "status", "completed")

update_task_field(task_id, "progress", 100)

update_task_field(task_id, "message", "Draft creation completed")

logger.info(f"Task {task_id} completed, draft URL: {draft_url}")

return draft_url

except Exception as e:

# Update task status - Failed

update_task_fields(task_id,

status="failed",

message=f"Failed to save draft: {str(e)}")

logger.error(f"Saving draft {draft_id} task {task_id} failed: {str(e)}", exc_info=True)

"""Start a background task to save the draft"""

logger.info(f"Received save draft request: draft_id={draft_id}, draft_folder={draft_folder}")

try:

# Generate a unique task ID

task_id = draft_id

create_task(task_id)

logger.info(f"Task {task_id} has been created.")

# Changed to synchronous execution

return {

"success": True,

"draft_url": save_draft_background(draft_id, draft_folder, task_id)

}

# # Start a background thread to execute the task

# thread = threading.Thread(

# target=save_draft_background,

# args=(draft_id, draft_folder, task_id)

# )

# thread.start()

except Exception as e:

logger.error(f"Failed to start save draft task {draft_id}: {str(e)}", exc_info=True)

return {

"success": False,

"error": str(e)

"""

# Process audio file metadata

audios = script.materials.audios

if not audios:

logger.info("No audio files found in the draft.")

else:

for audio in audios:

remote_url = audio.remote_url

material_name = audio.material_name

if not remote_url:

logger.warning(f"Warning: Audio file {material_name} has no remote_url, skipped.")

continue

try:

video_command = [

'ffprobe',

'-v', 'error',

'-select_streams', 'v:0',

'-show_entries', 'stream=codec_type',

'-of', 'json',

remote_url

]

video_result = subprocess.check_output(video_command, stderr=subprocess.STDOUT)

video_result_str = video_result.decode('utf-8')

# Find JSON start position (first '{')

video_json_start = video_result_str.find('{')

if video_json_start != -1:

video_json_str = video_result_str[video_json_start:]

video_info = json.loads(video_json_str)

if 'streams' in video_info and len(video_info['streams']) > 0:

logger.warning(f"Warning: Audio file {material_name} contains video tracks, skipped its metadata update.")

continue

except Exception as e:

logger.error(f"Error occurred while checking if audio {material_name} contains video streams: {str(e)}", exc_info=True)

# Get audio duration and set it

try:

duration_result = get_video_duration(remote_url)

if duration_result["success"]:

if task_id:

update_task_field(task_id, "message", f"Processing audio metadata: {material_name}")

# Convert seconds to microseconds

audio.duration = int(duration_result["output"] * 1000000)

logger.info(f"Successfully obtained audio {material_name} duration: {duration_result['output']:.2f} seconds ({audio.duration} microseconds).")

# Update timerange for all segments using this audio material

for track_name, track in script.tracks.items():

if track.track_type == draft.Track_type.audio:

for segment in track.segments:

if isinstance(segment, draft.Audio_segment) and segment.material_id == audio.material_id:

# Get current settings

current_target = segment.target_timerange

current_source = segment.source_timerange

speed = segment.speed.speed

# If the end time of source_timerange exceeds the new audio duration, adjust it

if current_source.end > audio.duration or current_source.end <= 0:

# Adjust source_timerange to fit the new audio duration

new_source_duration = audio.duration - current_source.start

if new_source_duration <= 0:

logger.warning(f"Warning: Audio segment {segment.segment_id} start time {current_source.start} exceeds audio duration {audio.duration}, will skip this segment.")

continue

# Update source_timerange

segment.source_timerange = draft.Timerange(current_source.start, new_source_duration)

# Update target_timerange based on new source_timerange and speed

new_target_duration = int(new_source_duration / speed)

segment.target_timerange = draft.Timerange(current_target.start, new_target_duration)

logger.info(f"Adjusted audio segment {segment.segment_id} timerange to fit the new audio duration.")

else:

logger.warning(f"Warning: Unable to get audio {material_name} duration: {duration_result['error']}.")

except Exception as e:

logger.error(f"Error occurred while getting audio {material_name} duration: {str(e)}", exc_info=True)

# Process video and image file metadata

videos = script.materials.videos

if not videos:

logger.info("No video or image files found in the draft.")

else:

for video in videos:

remote_url = video.remote_url

material_name = video.material_name

if not remote_url:

logger.warning(f"Warning: Media file {material_name} has no remote_url, skipped.")

continue

if video.material_type == 'photo':

# Use imageio to get image width/height and set it

try:

if task_id:

update_task_field(task_id, "message", f"Processing image metadata: {material_name}")

img = imageio.imread(remote_url)

video.height, video.width = img.shape[:2]

logger.info(f"Successfully set image {material_name} dimensions: {video.width}x{video.height}.")

except Exception as e:

logger.error(f"Failed to set image {material_name} dimensions: {str(e)}, using default values 1920x1080.", exc_info=True)

video.width = 1920

video.height = 1080

elif video.material_type == 'video':

# Get video duration and width/height information

try:

if task_id:

update_task_field(task_id, "message", f"Processing video metadata: {material_name}")

# Use ffprobe to get video information

command = [

'ffprobe',

'-v', 'error',

'-select_streams', 'v:0', # Select the first video stream

'-show_entries', 'stream=width,height,duration',

'-show_entries', 'format=duration',

'-of', 'json',

remote_url

]

result = subprocess.check_output(command, stderr=subprocess.STDOUT)

result_str = result.decode('utf-8')

# Find JSON start position (first '{')

json_start = result_str.find('{')

if json_start != -1:

json_str = result_str[json_start:]

info = json.loads(json_str)

if 'streams' in info and len(info['streams']) > 0:

stream = info['streams'][0]

# Set width and height

video.width = int(stream.get('width', 0))

video.height = int(stream.get('height', 0))

logger.info(f"Successfully set video {material_name} dimensions: {video.width}x{video.height}.")

# Set duration

# Prefer stream duration, if not available use format duration

duration = stream.get('duration') or info['format'].get('duration', '0')

video.duration = int(float(duration) * 1000000) # Convert to microseconds

logger.info(f"Successfully obtained video {material_name} duration: {float(duration):.2f} seconds ({video.duration} microseconds).")

# Update timerange for all segments using this video material

for track_name, track in script.tracks.items():

if track.track_type == draft.Track_type.video:

for segment in track.segments:

if isinstance(segment, draft.Video_segment) and segment.material_id == video.material_id:

# Get current settings

current_target = segment.target_timerange

current_source = segment.source_timerange

speed = segment.speed.speed

# If the end time of source_timerange exceeds the new video duration, adjust it

if current_source.end > video.duration or current_source.end <= 0:

# Adjust source_timerange to fit the new video duration

new_source_duration = video.duration - current_source.start

if new_source_duration <= 0:

logger.warning(f"Warning: Video segment {segment.segment_id} start time {current_source.start} exceeds video duration {video.duration}, will skip this segment.")

continue

# Update source_timerange

segment.source_timerange = draft.Timerange(current_source.start, new_source_duration)

# Update target_timerange based on new source_timerange and speed

new_target_duration = int(new_source_duration / speed)

segment.target_timerange = draft.Timerange(current_target.start, new_target_duration)

logger.info(f"Adjusted video segment {segment.segment_id} timerange to fit the new video duration.")

else:

logger.warning(f"Warning: Unable to get video {material_name} stream information.")

# Set default values

video.width = 1920

video.height = 1080

else:

logger.warning(f"Warning: Could not find JSON data in ffprobe output.")

# Set default values

video.width = 1920

video.height = 1080

except Exception as e:

logger.error(f"Error occurred while getting video {material_name} information: {str(e)}, using default values 1920x1080.", exc_info=True)

# Set default values

video.width = 1920

video.height = 1080

# Try to get duration separately

try:

duration_result = get_video_duration(remote_url)

if duration_result["success"]:

# Convert seconds to microseconds

video.duration = int(duration_result["output"] * 1000000)

logger.info(f"Successfully obtained video {material_name} duration: {duration_result['output']:.2f} seconds ({video.duration} microseconds).")

else:

logger.warning(f"Warning: Unable to get video {material_name} duration: {duration_result['error']}.")

except Exception as e2:

logger.error(f"Error occurred while getting video {material_name} duration: {str(e2)}.", exc_info=True)

# After updating all segments' timerange, check if there are time range conflicts in each track, and delete the later segment in case of conflict

logger.info("Checking track segment time range conflicts...")

for track_name, track in script.tracks.items():

# Use a set to record segment indices that need to be deleted

to_remove = set()

# Check for conflicts between all segments

for i in range(len(track.segments)):

# Skip if current segment is already marked for deletion

if i in to_remove:

continue

for j in range(len(track.segments)):

# Skip self-comparison and segments already marked for deletion

if i == j or j in to_remove:

continue

# Check if there is a conflict

if track.segments[i].overlaps(track.segments[j]):

# Always keep the segment with the smaller index (added first)

later_index = max(i, j)

logger.warning(f"Time range conflict between segments {track.segments[min(i, j)].segment_id} and {track.segments[later_index].segment_id} in track {track_name}, deleting the later segment")

to_remove.add(later_index)

# Delete marked segments from back to front to avoid index change issues

for index in sorted(to_remove, reverse=True):

track.segments.pop(index)

# After updating all segments' timerange, recalculate the total duration of the script

max_duration = 0

for track_name, track in script.tracks.items():

for segment in track.segments:

max_duration = max(max_duration, segment.end)

script.duration = max_duration

logger.info(f"Updated script total duration to: {script.duration} microseconds.")

# Process all pending keyframes in tracks

logger.info("Processing pending keyframes...")

for track_name, track in script.tracks.items():

if hasattr(track, 'pending_keyframes') and track.pending_keyframes:

logger.info(f"Processing {len(track.pending_keyframes)} pending keyframes in track {track_name}...")

track.process_pending_keyframes()

"""

# Get draft information from global cache

if draft_id not in DRAFT_CACHE:

logger.warning(f"Draft {draft_id} does not exist in cache.")

return None

script = DRAFT_CACHE[draft_id]

logger.info(f"Retrieved draft {draft_id} from cache.")

# If force_update is True, force refresh media metadata

if force_update:

logger.info(f"Force refreshing media metadata for draft {draft_id}.")

update_media_metadata(script)

# Return script object

"""Downloads the draft script and its associated media assets.

logger.info(f"Starting to download draft: {draft_id} to folder: {draft_folder}")

# Copy template to target directory

template_path = os.path.join("./", 'template') if IS_CAPCUT_ENV else os.path.join("./", 'template_jianying')

new_draft_path = os.path.join(draft_folder, draft_id)

if os.path.exists(new_draft_path):

logger.warning(f"Deleting existing draft target folder: {new_draft_path}")

shutil.rmtree(new_draft_path)

# Copy draft folder

shutil.copytree(template_path, new_draft_path)

try:

# 1. Fetch the script from the remote endpoint

if script_data is None:

query_url = "https://cut-jianying-vdvswivepm.cn-hongkong.fcapp.run/query_script"

headers = {"Content-Type": "application/json"}

payload = {"draft_id": draft_id}

logger.info(f"Attempting to get script for draft ID: {draft_id} from {query_url}.")

response = requests.post(query_url, headers=headers, json=payload)

response.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)

script_data = json.loads(response.json().get('output'))

logger.info(f"Successfully retrieved script data for draft {draft_id}.")

else:

logger.info(f"Using provided script_data, skipping remote retrieval.")

# Collect download tasks

download_tasks = []

# Collect audio download tasks

audios = script_data.get('materials',{}).get('audios',[])

if audios:

for audio in audios:

remote_url = audio['remote_url']

material_name = audio['name']

# Use helper function to build path

if draft_folder:

audio['path']=build_asset_path(draft_folder, draft_id, "audio", material_name)

logger.debug(f"Local path for audio {material_name}: {audio['path']}")

if not remote_url:

logger.warning(f"Audio file {material_name} has no remote_url, skipping download.")

continue

# Add audio download task

download_tasks.append({

'type': 'audio',

'func': download_file,

'args': (remote_url, audio['path']),

'material': audio

})

# Collect video and image download tasks

videos = script_data['materials']['videos']

if videos:

for video in videos:

remote_url = video['remote_url']

material_name = video['material_name']

if video['type'] == 'photo':

# Use helper function to build path

if draft_folder:

video['path'] = build_asset_path(draft_folder, draft_id, "image", material_name)

if not remote_url:

logger.warning(f"Image file {material_name} has no remote_url, skipping download.")

continue

# Add image download task

download_tasks.append({

'type': 'image',

'func': download_file,

'args': (remote_url, video['path']),

'material': video

})

elif video['type'] == 'video':

# Use helper function to build path

if draft_folder:

video['path'] = build_asset_path(draft_folder, draft_id, "video", material_name)

if not remote_url:

logger.warning(f"Video file {material_name} has no remote_url, skipping download.")

continue

# Add video download task

download_tasks.append({

'type': 'video',

'func': download_file,

'args': (remote_url, video['path']),

'material': video

})

# Execute all download tasks concurrently

downloaded_paths = []

completed_files = 0

if download_tasks:

logger.info(f"Starting concurrent download of {len(download_tasks)} files...")

# Use thread pool for concurrent downloads, maximum concurrency of 16

with ThreadPoolExecutor(max_workers=16) as executor:

# Submit all download tasks

future_to_task = {

executor.submit(task['func'], *task['args']): task

for task in download_tasks

}

# Wait for all tasks to complete

for future in as_completed(future_to_task):

task = future_to_task[future]

try:

local_path = future.result()

downloaded_paths.append(local_path)

# Update task status - only update completed files count

completed_files += 1

logger.info(f"Downloaded {completed_files}/{len(download_tasks)} files.")

except Exception as e:

logger.error(f"Failed to download {task['type']} file {task['args'][0]}: {str(e)}", exc_info=True)

logger.error("Download failed.")

# Continue processing other files, don't interrupt the entire process

logger.info(f"Concurrent download completed, downloaded {len(downloaded_paths)} files in total.")

"""Write draft file content to file"""

with open(f"{draft_folder}/{draft_id}/draft_info.json", "w", encoding="utf-8") as f:

f.write(json.dumps(script_data))

logger.info(f"Draft has been saved.")

# No draft_url for download, but return success

return {"success": True, "message": f"Draft {draft_id} and its assets downloaded successfully"}

except requests.exceptions.RequestException as e:

logger.error(f"API request failed: {e}", exc_info=True)

return {"success": False, "error": f"Failed to fetch script from API: {str(e)}"}

except Exception as e:

logger.error(f"Unexpected error during download: {e}", exc_info=True)