'commit'

DouYin/transcribe_videos.py

@@ -0,0 +1,135 @@
+
+import os
+import asyncio
+import logging
+import sys
+from dashscope import Files
+
+# Ensure project root is in path
+sys.path.append(r"d:\dsWork\aiData")
+from Util.ASRClient import ASRClient
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("Transcriber")
+
+async def transcribe_all():
+    audio_dir = r"d:\dsWork\aiData\DouYin\Audios"
+    transcript_dir = r"d:\dsWork\aiData\DouYin\Transcripts"
+    
+    if not os.path.exists(transcript_dir):
+        os.makedirs(transcript_dir)
+        
+    client = ASRClient()
+    
+    files = [f for f in os.listdir(audio_dir) if f.endswith(".mp3")]
+    logger.info(f"Found {len(files)} audio files.")
+    
+    for filename in files:
+        audio_path = os.path.join(audio_dir, filename)
+        name, _ = os.path.splitext(filename)
+        txt_filename = f"{name}.txt"
+        txt_path = os.path.join(transcript_dir, txt_filename)
+        
+        if os.path.exists(txt_path):
+            logger.info(f"Skipping (already exists): {txt_filename}")
+            continue
+            
+        logger.info(f"Processing: {filename}")
+        
+        uploaded_file = None
+        try:
+            # 1. Upload file to DashScope
+            logger.info(f"Uploading {filename} to DashScope...")
+            # Use purpose='assistants' to bypass jsonl check
+            upload_resp = Files.upload(audio_path, purpose='assistants', description=filename)
+            
+            if upload_resp.status_code == 200:
+                # Handle output structure (dict or object)
+                output_data = upload_resp.output
+                uploaded_files = None
+                
+                if hasattr(output_data, 'uploaded_files'):
+                    uploaded_files = output_data.uploaded_files
+                elif isinstance(output_data, dict):
+                    uploaded_files = output_data.get('uploaded_files')
+                
+                if not uploaded_files:
+                     logger.error(f"No uploaded_files in response: {output_data}")
+                     continue
+
+                uploaded_file = uploaded_files[0]
+                logger.info(f"Uploaded file info: {uploaded_file}")
+                
+                # Handle uploaded_file structure
+                file_id = None
+                if hasattr(uploaded_file, 'file_id'):
+                    file_id = uploaded_file.file_id
+                elif isinstance(uploaded_file, dict):
+                    file_id = uploaded_file.get('file_id')
+                
+                if not file_id:
+                    logger.error(f"No file_id in uploaded file: {uploaded_file}")
+                    continue
+
+                logger.info(f"Uploaded successfully. File ID: {file_id}")
+                
+                # Try passing file_id. If that fails, we might need another approach.
+                # According to some docs, file_urls=["file-xxx"] works.
+                target_url = file_id 
+            else:
+                logger.error(f"Upload failed: {upload_resp}")
+                continue
+                
+            # 2. Transcribe
+            logger.info(f"Transcribing {file_id}...")
+            output = await client.transcribe_audio(file_urls=[target_url])
+            
+            if output and output.task_status == 'SUCCEEDED':
+                # Parse results
+                results = output.results
+                if results:
+                    for res in results:
+                        transcription_url = res.get('transcription_url')
+                        if transcription_url:
+                            # Download result
+                            trans_data = await client.download_transcription_result(transcription_url)
+                            if trans_data:
+                                # Extract text
+                                # text_with_ts = await client.extract_transcript_with_timestamp(trans_data)
+                                text_clean = await client.extract_transcript_without_timestamp(trans_data)
+                                
+                                # Save to file
+                                with open(txt_path, 'w', encoding='utf-8') as f:
+                                    f.write(text_clean)
+                                logger.info(f"Saved transcript to: {txt_filename}")
+                            else:
+                                logger.error(f"Failed to download transcript for {filename}")
+                        else:
+                            logger.error(f"No transcription_url in result for {filename}")
+                else:
+                    logger.error(f"No results in output for {filename}")
+            else:
+                logger.error(f"Transcription failed for {filename}")
+                
+        except Exception as e:
+            logger.error(f"Error processing {filename}: {e}")
+        
+        finally:
+            # 3. Cleanup: Delete uploaded file
+            if uploaded_file:
+                try:
+                    fid = None
+                    if hasattr(uploaded_file, 'file_id'):
+                        fid = uploaded_file.file_id
+                    elif isinstance(uploaded_file, dict):
+                        fid = uploaded_file.get('file_id')
+                    
+                    if fid:
+                        Files.delete(fid)
+                        logger.info(f"Deleted remote file {fid}")
+                except Exception as e:
+                    logger.warning(f"Failed to delete remote file: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(transcribe_all())