Upload 2 files

transcribe.py

@@ -0,0 +1,130 @@
+from faster_whisper import WhisperModel
+import math
+
+
+def word_level_transcribe(audio, max_segment_duration=2.0):  # Set your desired max duration here
+    model = WhisperModel("tiny", device="cpu", cpu_threads=12, local_files_only=True)
+    segments, info = model.transcribe(audio, vad_filter=True, vad_parameters=dict(min_silence_duration_ms=1500), word_timestamps=True, log_progress=True)
+    segments = list(segments)  # The transcription will actually run here.
+    wordlevel_info = []
+    for segment in segments:
+        for word in segment.words:
+          print("[%.2fs -> %.2fs] %s" % (word.start, word.end, word.word))
+          wordlevel_info.append({'word':word.word,'start':word.start,'end':word.end})
+    return wordlevel_info
+
+def create_subtitles(wordlevel_info):
+    punctuation_marks = {'.', '!', '?', ',', ';', ':', '—', '-', '。', '！', '？'}  # Add/remove punctuation as needed
+    subtitles = []
+    line = []
+
+    for word_data in wordlevel_info:
+        line.append(word_data)
+        current_word = word_data['word']
+
+        # Check if current word ends with punctuation or line reached 5 words
+        ends_with_punct = current_word and (current_word[-1] in punctuation_marks)
+
+        if ends_with_punct or len(line) == 5:
+            # Create a new subtitle segment
+            subtitle = {
+                "word": " ".join(item["word"] for item in line),
+                "start": line[0]["start"],
+                "end": line[-1]["end"],
+                "textcontents": line.copy()
+            }
+            subtitles.append(subtitle)
+            line = []
+
+    # Add remaining words if any
+    if line:
+        subtitle = {
+            "word": " ".join(item["word"] for item in line),
+            "start": line[0]["start"],
+            "end": line[-1]["end"],
+            "textcontents": line.copy()
+        }
+        subtitles.append(subtitle)
+
+    # Remove gaps between segments by extending the previous segment's end time
+    for i in range(1, len(subtitles)):
+        prev_subtitle = subtitles[i - 1]
+        current_subtitle = subtitles[i]
+
+        # Extend the previous segment's end time to the start of the current segment
+        prev_subtitle["end"] = current_subtitle["start"]
+
+    return subtitles
+
+def format_time(seconds):
+    hours = math.floor(seconds / 3600)
+    seconds %= 3600
+    minutes = math.floor(seconds / 60)
+    seconds %= 60
+    milliseconds = round((seconds - math.floor(seconds)) * 1000)
+    seconds = math.floor(seconds)
+    formatted_time = f"{hours:02d}:{minutes:02d}:{seconds:01d},{milliseconds:03d}"
+    return formatted_time
+
+def generate_subtitle_file(language, segments, input_video_name):
+    subtitle_file = f"./src/media/sub-{input_video_name}.{language}.srt"
+    text = ""
+    for index, segment in enumerate(segments):
+        segment_start = format_time(segment['start'])
+        segment_end = format_time(segment['end'])
+        text += f"{str(index+1)} \n"
+        text += f"{segment_start} --> {segment_end} \n"
+        text += f"{segment['word']} \n"
+        text += "\n"
+    f = open(subtitle_file, "w", encoding='utf8')
+    f.write(text)
+    f.close()
+    return subtitle_file
+
+def split_srt_file(input_file, max_chars=3000):
+    # Read the contents of the SRT file
+    with open(input_file, 'r', encoding='utf-8') as file:
+        content = file.read()
+    file.close()
+
+    # Split the content into individual subtitles
+    subtitles = content.strip().split('\n\n')
+
+    # Prepare to write the split files
+    output_files = []
+    current_file_content = ''
+    current_file_index = 1
+
+    for subtitle in subtitles:
+        # Check if adding this subtitle would exceed the character limit
+        if len(current_file_content) + len(subtitle) + 2 > max_chars:  # +2 for \n\n
+            # Write the current file
+            output_file_name = f'./src/media/split_{current_file_index}.srt'
+            with open(output_file_name, 'w', encoding='utf-8') as output_file:
+                output_file.write(current_file_content.strip())
+            output_files.append(output_file_name)
+
+            # Prepare for the next file
+            current_file_index += 1
+            current_file_content = subtitle + '\n\n'
+        else:
+            # If it fits, add the subtitle
+            current_file_content += subtitle + '\n\n'
+
+    # Write any remaining content to a new SRT file
+    if current_file_content:
+        output_file_name = f'./src/media/split_{current_file_index}.srt'
+        with open(output_file_name, 'w', encoding='utf-8') as output_file:
+            output_file.write(current_file_content.strip())
+        output_files.append(output_file_name)
+
+    return output_files
+
+def transcribe(mp3_file):
+
+    print("transcribe")
+    wordlevel_info=word_level_transcribe(mp3_file)
+    subtitles = create_subtitles(wordlevel_info)
+    subtitle_file = generate_subtitle_file('fa', subtitles, 'video_subtitled')
+    srt_list = split_srt_file(subtitle_file)
+    return srt_list

translate.py

@@ -0,0 +1,114 @@
+import time
+import requests
+import re
+api_key = "268976:66f4f58a2a905"
+
+
+def read_srt_file(file_path):
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            srt_content = file.read()
+            return srt_content
+    except FileNotFoundError:
+        print(f"The file {file_path} was not found.")
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+def clean_text(text):
+    # Remove 'srt ' from the start of each line
+    # Remove ''' from the start and end
+    text = re.sub(r"^```|```$", '', text)
+    text = re.sub(r'^srt', '', text, flags=re.MULTILINE)
+    return text
+
+def translate_text(api_key, text, source_language = "en", target_language = "fa"):
+    url = "https://api.one-api.ir/translate/v1/google/"
+    request_body = {"source": source_language, "target": target_language, "text": text}
+    headers = {"one-api-token": api_key, "Content-Type": "application/json"}
+    response = requests.post(url, headers=headers, json=request_body)
+    if response.status_code == 200:
+        result = response.json()
+        return result['result']
+    else:
+        print(f"Error: {response.status_code}, {response.text}")
+        return None
+
+def enhance_text(api_key, text):
+    url = "https://api.one-api.ir/chatbot/v1/gpt4o/"
+
+    # Prepare the request body
+    request_body = [{
+        "role": "user",
+        "content":  f"Please take the following SRT subtitle text in English and translate only the subtitle text into Persian. Ensure that all numbering and time codes remain unchanged. The output should be a new SRT file with the subtitles in Persian, preserving the original formatting and timings and exept for the subtitle dont return anything in response. the subtitle will be provided in the following message"
+    },
+    {
+    "role": "assistant",
+    "content": "okay"
+    },
+    {
+    "role": "user",
+    "content": text
+    }
+    ]
+
+    # Add the API key to the request
+    headers = {
+        "one-api-token": api_key,
+        "Content-Type": "application/json"
+    }
+
+    # Make the POST request
+    attempts = 0
+    max_attempts = 3
+
+    while attempts < max_attempts:
+        response = requests.post(url, headers=headers, json=request_body)
+        if response.status_code == 200:
+            result = response.json()
+            if result["status"] == 200:
+                print("status: ", result["status"])
+                te = clean_text(result["result"][0])
+                print("result: ", te)
+                return te
+            else:
+                print(f"Error: status {result['status']}, retrying in 30 seconds...")
+        else:
+            print(f"Error: {response.status_code}, {response.text}, retrying in 30 seconds...")
+        attempts += 1
+        time.sleep(30)
+    print("Error Max attempts reached. Could not retrieve a successful response.")
+    te = translate_text(api_key, text)
+    return te
+
+
+def generate_translated_subtitle(language, segments, input_video_name):
+    input_video_name=input_video_name.split('/')[-1]
+    subtitle_file = f"./src/media/{input_video_name}.srt"
+    text = ""
+    lines = segments.split('\n')
+    new_list = [item for item in lines if item != '']
+    segment_number = 1
+
+    for index, segment in enumerate(new_list):
+        if (index+1) % 3 == 1 or (index+1)==1:
+            text += f"{segment}\n"
+            segment_number += 1
+        if (index+1) % 3 == 2 or (index+1)==2:
+            text += segment + "\n"
+        if (index+1) % 3 == 0:
+            text += f"\u200F{segment}\n\n"
+
+    with open(subtitle_file, "a", encoding='utf8') as f:
+        f.write(text)
+    return subtitle_file
+
+def translate(srt_files):
+    print("translate")
+    for srt_file in srt_files:
+        srt = read_srt_file(srt_file)
+        srt_string = enhance_text(api_key, srt)
+        print(srt_string)
+        subtitle_file = generate_translated_subtitle('fa', srt_string, 'video_subtitled')
+        time.sleep(10)
+
+    return subtitle_file