Skip to content
The Chat Archive
llama-4-maverick-03-26-experimental· Meta LMArena Human Preference 140K

stwórz skrypt z ustrukturuzywaniem treści z filmiku pod linkiem…

  1. User

    stwórz skrypt z ustrukturuzywaniem treści z filmiku pod linkiem https://www.youtube.com/watch?v=vSWr9ew9opc&t=27s

  2. Assistant

    Ciekawy projekt! Poniżej przedstawiam skrypt w Pythonie, który wykorzystuje bibliotekę pytube do pobrania treści z filmu na YouTube oraz moviepy do wyodrębnienia audio i transkrypcji tekstu z tego filmu. Dodatkowo użyty zostanie youtube-transcript-api do pobrania transkrypcji filmu, jeśli jest dostępna.

    Zanim zaczniemy, upewnij się, że masz zainstalowane niezbędne biblioteki. Możesz je zainstalować za pomocą pip:

    pip install pytube moviepy youtube_transcript_api
    

    Teraz przejdźmy do skryptu:

    from pytube import YouTube
    from moviepy.editor import *
    import os
    from youtube_transcript_api import YouTubeTranscriptApi
    
    # Link do filmiku
    video_url = "https://www.youtube.com/watch?v=vSWr9ew9opc&t=27s"
    
    # Funkcja do pobrania wideo
    def pobierz_wideo(url):
        yt = YouTube(url)
        print(f"Pobieranie: {yt.title}")
        
        # Pobierz tylko ścieżkę audio, ponieważ nas interesuje treść mówiona
        stream = yt.streams.filter(only_audio=True).first()
        downloaded_file = stream.download()
        
        # Konwertuj nazwę pliku do mp3 (moviepy lepiej działa z plikami mp3)
        base, ext = os.path.splitext(downloaded_file)
        audio_file = base + '.mp3'
        os.rename(downloaded_file, audio_file)
        
        return audio_file, yt.title
    
    # Funkcja do transkrypcji audio (dość zasobożerna i nie zawsze dokładna)
    def transkrybuj_audio(audio_file):
        from vosk import Model, KaldiRecognizer, SetLogLevel
        import wave
        import json
        
        # Zainstaluj model Vosk dla języka polskiego: https://alphacephei.com/vosk/models
        # Poniżej przykład dla polskiego modelu, pobierz i rozpakuj model do folderu `model`
        model_path = "model/vosk-model-small-pl-0.22"
        if not os.path.exists(model_path):
            print("Nie znaleziono modelu Vosk dla języka polskiego. Pobierz model z https://alphacephei.com/vosk/models")
            return ""
        
        SetLogLevel(0)
        model = Model(model_path)
        rec = KaldiRecognizer(model, 16000)
    
        wf = wave.open(audio_file, "rb")
        if wf.getnchannels() != 1 or wf.getsampwidth() != 2 or wf.getframerate() != 16000:
            print("Plik audio musi być w formacie mono, 16bit, 16kHz")
            return ""
    
        tekst = ""
        while True:
            data = wf.readframes(4000)
            if len(data) == 0:
                break
            if rec.AcceptWaveform(data):
                wynik = json.loads(rec.Result())
                tekst += wynik['text'] + " "
    
        wynik = json.loads(rec.FinalResult())
        tekst += wynik['text']
        return tekst
    
    # Funkcja do pobrania transkrypcji bezpośrednio z YouTube (jeśli dostępna)
    def pobierz_transkrypcje_yt(video_id):
        try:
            transcript = YouTubeTranscriptApi.get_transcript(video_id)
            tekst = " ".join([t['text'] for t in transcript])
            return tekst
        except Exception as e:
            print(f"Błąd pobierania transkrypcji: {e}")
            return ""
    
    # Główna część skryptu
    if __name__ == "__main__":
        yt = YouTube(video_url)
        video_id = yt.video_id  # Pobierz ID filmu
        
        # Spróbuj najpierw pobrać transkrypcję bezpośrednio z YouTube
        transkrypcja_yt = pobierz_transkrypcje_yt(video_id)
        
        if transkrypcja_yt:
            print("\nTranskrypcja z YouTube:")
            print(transkrypcja_yt)
        else:
            print("Brak transkrypcji na YouTube, pobieram plik audio...")
            
            # Pobierz plik audio
            audio_file, title = pobierz_wideo(video_url)
            print(f"Plik audio zapisany jako: {audio_file}")
            
            # Konwertuj audio do wav (bo Vosk wymaga wave 16kHz)
            audio = AudioFileClip(audio_file)
            wav_file = audio_file.replace('.mp3', '.wav')
            audio.write_audiofile(wav_file, fps=16000, nbytes=2, codec='pcm_s16le')
            audio.close()
            
            # Wykonaj transkrypcję lokalnie
            print("Trwa transkrypcja audio...")
            transkrypcja_local = transkrybuj_audio(wav_file)
            
            if transkrypcja_local:
                print("\nTranskrypcja lokalna:")
                print(transkrypcja_local)
            else:
                print("Nie udało się uzyskać transkrypcji.")
            
            # Opcjonalnie - posprzątaj pliki
            # os.remove(audio_file)
            # os.remove(wav_file)
    
        print("\nZakończono proces.")
    

    Jak to działa?

    1. Pobranie transkrypcji z YouTube: Najpierw skrypt próbuje skorzystać z API transkrypcji YouTube. Jeśli film ma włączone napisy (automatyczne lub ręczne), to je pobiera. To najprostszy i najdokładniejszy sposób.
    2. Pobranie audio: Jeśli nie ma transkrypcji, pobiera ścieżkę audio z filmu.
    3. Transkrypcja lokalna: Następnie konwertuje audio do formatu obsługiwanego przez silnik Vosk (wymagany model języka polskiego) i transkrybuje tekst.

    Ważne uwagi:

    1. Model Vosk: Do transkrypcji lokalnej potrzebny jest model języka polskiego. Pobierz go stąd: https://alphacephei.com/vosk/models (np. vosk-model-small-pl-0.22). Rozpakuj do folderu model w miejscu skryptu.
    2. Wymagania sprzętowe: Transkrypcja lokalna jest bardzo zasobożerna (CPU i RAM). Na słabszym komputerze może nie działać zbyt szybko.
    3. Dokładność: Transkrypcja z YouTube jest zazwyczaj dokładniejsza niż lokalna (bo korzysta z usług Google).
    4. Prawa autorskie: Pamiętaj, że pobieranie treści z YouTube może podlegać ograniczeniom prawnym. Używaj tego skryptu tylko do analizy materiałów, do których masz odpowiednie prawa.

    Jeśli wszystko skonfigurujesz prawidłowo, otrzymasz w efekcie pełną treść mówioną z filmu w postaci tekstu. Miłej analizy! 😊

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.