notesync_core.py

import os
import re
from uuid import uuid4
from collections import Counter
import whisper
from moviepy.editor import VideoFileClip
from yt_dlp import YoutubeDL
import nltk
from nltk.corpus import stopwords
import spacy
from transformers import MarianMTModel, MarianTokenizer, M2M100ForConditionalGeneration, M2M100Tokenizer
from faster_whisper import WhisperModel

# הורדת רשימות stopwords
nltk.download("stopwords")

# הגדרת תיקיית העלאות
UPLOAD_FOLDER = "uploads"
os.makedirs(UPLOAD_FOLDER, exist_ok=True)

# טעינת מודלים של spaCy לפי שפה
spacy_models = {
    "en": spacy.load("en_core_web_sm"),
    "fr": spacy.load("fr_core_news_sm"),
    "es": spacy.load("es_core_news_sm"),
    "de": spacy.load("de_core_news_sm"),
    "sv": spacy.load("sv_core_news_sm")
}

# רשימות stopwords לכל שפה
stop_words = {
    "en": set(stopwords.words("english")),
    "fr": set(stopwords.words("french")),
    "es": set(stopwords.words("spanish")),
    "de": set(stopwords.words("german")),
    "sv": set(stopwords.words("swedish"))
}

# טעינת מודלים לתרגום לעברית לפי שפה
translation_models = {
    "en": MarianMTModel.from_pretrained("Helsinki-NLP/opus-mt-en-he"),
    "es": MarianMTModel.from_pretrained("Helsinki-NLP/opus-mt-es-he"),
    "fr": MarianMTModel.from_pretrained("Helsinki-NLP/opus-mt-fr-he"),
    "de": MarianMTModel.from_pretrained("Helsinki-NLP/opus-mt-de-he"),
    "sv": MarianMTModel.from_pretrained("Helsinki-NLP/opus-mt-sv-he")
}
# טוקניזרים מתאימים לכל שפה
translation_tokenizers = {
    "en": MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-he"),
    "es": MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-es-he"),
    "fr": MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-fr-he"),
    "de": MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-de-he"),
    "sv": MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-sv-he")
}

# מודל M2M100 לתרגום בין שפות (כללי יותר)
m2m_tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M")
m2m_model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M")

# פונקציה זו מתמללת קובץ אודיו 
# מזהה שפה, ואם היא נתמכת – מתרגמת לעברית. אחרת מתרגמת לאנגלית
def transcribe_audio(audio_path, mode="base"):
    supported_translation_langs = translation_models.keys()
    if mode == "medium":
        return transcribe_with_faster_whisper(audio_path, model_size="medium")

    print(f"🎤 Transcribing with Whisper base...")
    model = whisper.load_model("base")
    result = model.transcribe(audio_path, verbose=False, fp16=False)

    language = result["language"]
    print(f"🌐 Detected language: {language}")
    if language == "he":
        raise ValueError("⛔ שגיאה: המערכת אינה תומכת באודיו בעברית.")

    sentence_segments = segment_sentences_with_timestamps(result["segments"])
    full_text = result["text"].strip()

    if not sentence_segments:
        print("⚠️ No sentence segments found. Possibly Whisper failed to transcribe.")
        return {
            "language": language,
            "original_language": language,
            "segments": [],
            "full_text": full_text,
            "original_text": full_text
        }

    if language in supported_translation_langs:
        tokenizer = translation_tokenizers[language]
        model_he = translation_models[language]
        translations = []
        for s in sentence_segments:
            inputs = tokenizer(s["text"], return_tensors="pt", padding=True, truncation=True)
            output = model_he.generate(**inputs, max_length=128)
            translated_text = tokenizer.decode(output[0], skip_special_tokens=True)
            translations.append({"text": translated_text, "start": s["start"]})
        merged = merge_sentences_to_blocks(sentence_segments, translations=translations, original_lang=language)
        return {
            "language": "he",
            "original_language": language,
            "segments": merged,
            "full_text": full_text
        }

    print("🔁 No Hebrew model available. Using M2M100 to translate to English...")
    translations = translate_to_english_with_m2m(sentence_segments, language)
    translated_text = " ".join([s["text"] for s in translations])
    merged = merge_sentences_to_blocks(sentence_segments, translations=translations, original_lang=language)
    return {
        "language": "en",
        "original_language": language,
        "segments": merged,
        "full_text": translated_text,
        "original_text": full_text
    }


# תרגום של משפטים לשפה האנגלית באמצעות המודל הכללי 
# משמש כשאין מודל תרגום לעברית לשפה המקורית   
def translate_to_english_with_m2m(sentences, source_lang):
    translations = []
    m2m_tokenizer.src_lang = source_lang
    for s in sentences:
        text = s["text"].strip()
        start = s["start"]
        if not text:
            continue
        encoded = m2m_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
        generated = m2m_model.generate(**encoded, forced_bos_token_id=m2m_tokenizer.get_lang_id("en"))
        translated = m2m_tokenizer.batch_decode(generated, skip_special_tokens=True)[0]
        translations.append({"text": translated, "start": start})
    return translations
    

# תמלול אודיו עם מודל מהיר יותר
def transcribe_with_faster_whisper(audio_path, model_size="medium"):
    print(f"⚡ Using Faster-Whisper ({model_size})...")
    model = WhisperModel(model_size, device="cpu", compute_type="int8")
    segments, info = model.transcribe(audio_path, beam_size=1)

    sentence_segments = []
    full_text = ""
    for seg in segments:
        text = seg.text.strip()
        if len(text) > 2:
            sentence_segments.append({
                "start": round(seg.start, 2),
                "text": text
            })
            full_text += " " + text

    language = info.language
    print(f"🌐 Detected language: {language}")
    if language == "he":
        raise ValueError("⛔ שגיאה: המערכת אינה תומכת באודיו בעברית.")

    if not sentence_segments:
        print("⚠️ No sentence segments found. Possibly Faster-Whisper failed to transcribe.")
        return {
            "language": language,
            "original_language": language,
            "segments": [],
            "full_text": full_text.strip(),
            "original_text": full_text.strip()
        }

    supported_translation_langs = translation_models.keys()

    if language in supported_translation_langs:
        tokenizer = translation_tokenizers[language]
        model_he = translation_models[language]
        translations = []
        for s in sentence_segments:
            inputs = tokenizer(s["text"], return_tensors="pt", padding=True, truncation=True)
            output = model_he.generate(**inputs, max_length=128)
            translated_text = tokenizer.decode(output[0], skip_special_tokens=True)
            translations.append({"text": translated_text, "start": s["start"]})
        merged = merge_sentences_to_blocks(sentence_segments, translations=translations, original_lang=language)
        return {
            "language": "he",
            "original_language": language,
            "segments": merged,
            "full_text": full_text.strip()
        }

    print("🔁 No Hebrew model available. Using M2M100 to translate to English...")
    translations = translate_to_english_with_m2m(sentence_segments, language)
    translated_text = " ".join([s["text"] for s in translations])
    merged = merge_sentences_to_blocks(sentence_segments, translations=translations, original_lang=language)
    return {
        "language": "en",
        "original_language": language,
        "segments": merged,
        "full_text": translated_text,
        "original_text": full_text.strip()
    }


# חיתוך פסקאות למשפטים בודדים
# חישוב זמן תחילת כל משפט לפי מיקום יחסי בתמלול
def segment_sentences_with_timestamps(segments):
    sentence_segments = []
    for seg in segments:
        text = seg["text"].strip()
        start = seg["start"]
        end = seg["end"]
        sentences = re.findall(r'[^.!?]+[.!?]', text)
        total_chars = len(text)
        current_offset = 0
        for s in sentences:
            s = s.strip()
            if not s:
                continue
            rel_start = start + (current_offset / total_chars) * (end - start)
            if len(s.split()) >= 2:
                sentence_segments.append({"start": round(rel_start, 2), "text": s})
            current_offset += len(s)
    return sentence_segments

# מאחד משפטים לגושים של טקסט לפי זמן מצטבר 
def merge_sentences_to_blocks(sentence_segments, translations=None, original_lang=None, max_duration=60):
    merged = []
    current_block = []
    current_translations = []
    current_start = None
    for i, sent in enumerate(sentence_segments):
        if not current_block:
            current_start = sent["start"]
        current_block.append(sent)
        if translations:
            current_translations.append(translations[i] if i < len(translations) else {"text": "", "start": sent["start"]})
        current_duration = sent["start"] - current_start if sent["start"] > current_start else 0
        if current_duration >= max_duration:
            merged.append({
                "start": current_start,
                "text": " ".join(s["text"] for s in current_block),
                "sentences": current_block.copy(),
                "translations": current_translations.copy() if translations else None,
                "original_lang": original_lang
            })
            current_block = []
            current_translations = []
            current_start = None

    if current_block:
        merged.append({
            "start": current_block[0]["start"],
            "text": " ".join(s["text"] for s in current_block),
            "sentences": current_block.copy(),
            "translations": current_translations.copy() if translations else None,
            "original_lang": original_lang
        })
    return merged

# חילוץ מילות מפתח מהטקסט 
def extract_keywords_spacy(text, lang="en", top_n=None):
    if top_n is None:
        top_n = 10

    if lang == "he":
        print("⚠️ Hebrew detected, skipping keyword extraction.")
        return []

    if lang in spacy_models:
        doc = spacy_models[lang](text)
        nouns = [token.text.lower() for token in doc if token.pos_ in ["NOUN", "PROPN"] and not token.is_stop and len(token.text) > 2]
        freq = Counter(nouns)
        return [word for word, count in freq.most_common(top_n)]
    else:
        print(f"⚠️ No spaCy model for {lang}. Extracting common words instead.")
        words = re.findall(r'\b\w+\b', text.lower())
        filtered_words = [word for word in words if word not in stop_words.get("en", set())]
        filtered_words = [word for word, count in Counter(filtered_words).most_common(top_n)]  

    return filtered_words

#חילוץ אודיו מקובץ
def extract_audio(media_path):
    if media_path.lower().endswith(('.mp3', '.wav')):
        return media_path

    try:
        base_name = os.path.splitext(os.path.basename(media_path))[0]
        audio_path = os.path.join(UPLOAD_FOLDER, f"{base_name}.mp3")

        clip = VideoFileClip(media_path)
        if clip.audio is None:
            print(f"❌ Error: No audio stream found in {media_path}")
            return None

        clip.audio.write_audiofile(audio_path, codec="mp3")
        clip.close()

        print(f"✅ Audio extracted and saved to: {audio_path}")
        return audio_path

    except Exception as e:
        print(f"❌ Error processing audio: {e}")
        return None

#עיבוד אודיו
def process_media_file(media_path, mode="base"):
    title = os.path.splitext(os.path.basename(media_path))[0]
    audio_path = extract_audio(media_path)
    transcription = transcribe_audio(audio_path, mode=mode)

    merged_segments = transcription["segments"]
    keywords = extract_keywords_spacy(
        transcription.get("original_text", transcription["full_text"]),
        lang=transcription.get("original_language", transcription["language"])
    )

    return {
        "source": title,
        "language": transcription["language"],
        "original_language": transcription.get("original_language", transcription["language"]),
        "segments": merged_segments,
        "keywords": keywords,
        "audio_filename": os.path.basename(audio_path)
    }


def clean_youtube_link(url):
    return url.split("&")[0] if "&" in url else url

#הורדת סרטון יוטיוב כקובץ 
def download_youtube_audio(link, output_file_path):
    print("⬇️ Downloading audio from YouTube...")
    ydl_opts = {
        'format': 'bestaudio/best',
        'outtmpl': output_file_path,
        'postprocessors': [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': 'mp3',
            'preferredquality': '192',
        }],
        'quiet': False,
        'noplaylist': True
    }
    with YoutubeDL(ydl_opts) as ydl:
        ydl.download([link])
    print(f"✅ Saved YouTube audio to: {output_file_path}.mp3")


#עיבוד סרטון יוטיוב
def process_youtube_link(youtube_link, mode="base"):
    youtube_link = clean_youtube_link(youtube_link)
    unique_id = uuid4().hex[:8]
    output_path = os.path.join(UPLOAD_FOLDER, f"youtube_{unique_id}")
    download_youtube_audio(youtube_link, output_path)
    audio_path = output_path + ".mp3"

    transcription = transcribe_audio(audio_path, mode=mode)

    merged_segments = transcription["segments"]
    keywords = extract_keywords_spacy(
        transcription.get("original_text", transcription["full_text"]),
        lang=transcription.get("original_language", transcription["language"])
    )

    return {
        "source": youtube_link,
        "language": transcription["language"],
        "original_language": transcription.get("original_language", transcription["language"]),
        "segments": merged_segments,
        "keywords": keywords,
        "audio_filename": os.path.basename(audio_path)
    }