subtitld 0.0.0.dev0__py3-none-any.whl

subtitld/modules/usf.py

@@ -0,0 +1,366 @@
+"""USF (Universal Subtitle Format) reader/writer."""
+
+
+import base64
+import os
+
+from bs4 import BeautifulSoup, NavigableString
+import subtitld.modules.timecode as timecode
+
+
+USF_BASE_MARKUP = '''<!-- USF file generated by Subtitld -->
+<USFSubtitles version="1.0">
+    <metadata></metadata>
+    <styles></styles>
+</USFSubtitles>'''
+
+
+def _extract_inline_text(tag):
+    """Return the text of a tag, converting <br/> to \\n and flattening inline formatting."""
+    parts = []
+    for child in tag.children:
+        if isinstance(child, NavigableString):
+            parts.append(str(child))
+            continue
+        if child.name == 'br':
+            parts.append('\n')
+            continue
+        parts.append(_extract_inline_text(child))
+    return ''.join(parts).strip()
+
+
+def _parse_numeric(value, caster):
+    try:
+        return caster(value)
+    except (TypeError, ValueError):
+        return None
+
+
+class USFReader():
+    """USFReader class"""
+    def __init__(self, *args, **kwargs):
+        super(USFReader, self).__init__(*args, **kwargs)
+        self.metadata = {}
+        self.language = None
+        self.speakers = {}  # name -> {'color': '#RRGGBB'}
+        self.has_embedded_images = False
+        self.has_embedded_audio_clips = False
+
+    def detect(self, content):
+        """Function to return if this is a USF file"""
+        return '<usfsubtitles' in content.lower()
+
+    def read(self, content):
+        """Parse USF content and return a list of subtitle dicts.
+
+        Populates self.metadata, self.language and self.speakers as a side
+        effect so the caller can reflect title/author/date/language and the
+        per-speaker colors back into session state.
+        """
+        self.metadata = {}
+        self.language = None
+        self.speakers = {}
+        self.has_embedded_images = False
+        self.has_embedded_audio_clips = False
+
+        soup = BeautifulSoup(content, features="xml")
+
+        meta = soup.find('metadata')
+        if meta:
+            for key in ('title', 'date'):
+                tag = meta.find(key)
+                if tag and tag.text:
+                    self.metadata[key] = tag.text.strip()
+            lang = meta.find('language')
+            if lang and lang.attrs.get('code'):
+                self.language = lang.attrs['code']
+            author = meta.find('author')
+            if author:
+                name = author.find('name')
+                if name and name.text:
+                    self.metadata['author'] = name.text.strip()
+
+        for style in soup.select('styles > style'):
+            name = style.attrs.get('name')
+            if not name or name == 'Default':
+                continue
+            entry = {}
+            fontstyle = style.find('fontstyle')
+            if fontstyle and fontstyle.attrs.get('color'):
+                entry['color'] = fontstyle.attrs['color']
+            avatar = style.find('avatar')
+            if avatar and avatar.attrs.get('encoding') == 'base64' and avatar.text:
+                try:
+                    entry['image_bytes'] = base64.b64decode(avatar.text.strip())
+                    self.has_embedded_images = True
+                except Exception:
+                    pass
+            dub_elem = style.find('dubbing')
+            if dub_elem:
+                dub_data = {}
+                for key in ('engine', 'voice'):
+                    if key in dub_elem.attrs:
+                        dub_data[key] = dub_elem.attrs[key]
+                for key in ('rate', 'pitch'):
+                    if key in dub_elem.attrs:
+                        parsed = _parse_numeric(dub_elem.attrs[key], int)
+                        if parsed is not None:
+                            dub_data[key] = parsed
+                if dub_data:
+                    entry['dubbing'] = dub_data
+            if entry:
+                self.speakers[name] = entry
+
+        blocks = soup.find_all('subtitles')
+        if not blocks:
+            return []
+
+        primary_block = blocks[0]
+        primary_lang = self._block_language(primary_block)
+        if primary_lang and not self.language:
+            self.language = primary_lang
+
+        subtitles_list = []
+        for element in primary_block.find_all('subtitle', recursive=False):
+            entry = self._parse_subtitle(element)
+            if entry:
+                subtitles_list.append(entry)
+
+        for block in blocks[1:]:
+            lang = self._block_language(block)
+            if not lang:
+                continue
+            tr_subs = block.find_all('subtitle', recursive=False)
+            for primary_sub, tr_sub in zip(subtitles_list, tr_subs):
+                text_tag = tr_sub.find('text') or tr_sub.find('karaoke')
+                if text_tag is None:
+                    continue
+                primary_sub.setdefault('translations', {})[lang] = _extract_inline_text(text_tag)
+
+        return subtitles_list
+
+    def _block_language(self, block):
+        lang = block.find('language')
+        if lang and lang.attrs.get('code'):
+            return lang.attrs['code']
+        return None
+
+    def _parse_subtitle(self, element):
+        if 'start' not in element.attrs or 'stop' not in element.attrs:
+            return None
+
+        subtitle = {
+            'start': timecode.Timecode('1000', element.attrs['start']).float,
+            'end': timecode.Timecode('1000', element.attrs['stop']).float,
+        }
+
+        text_tag = element.find('text') or element.find('karaoke')
+        subtitle['text'] = _extract_inline_text(text_tag) if text_tag else ''
+        subtitle['speaker'] = (text_tag.attrs.get('speaker') if text_tag else None) or 'A'
+
+        dubs = []
+        for dub_elem in element.find_all('dubbing', recursive=False):
+            dub = {}
+            for key, value in dub_elem.attrs.items():
+                dub[key] = value
+            for key in ('start', 'end'):
+                if key in dub:
+                    parsed = _parse_numeric(dub[key], float)
+                    if parsed is not None:
+                        dub[key] = parsed
+            for key in ('rate', 'pitch'):
+                if key in dub:
+                    parsed = _parse_numeric(dub[key], int)
+                    if parsed is not None:
+                        dub[key] = parsed
+            data_tag = dub_elem.find('data')
+            if data_tag and data_tag.attrs.get('encoding') == 'base64' and data_tag.text:
+                try:
+                    dub['_embedded_bytes'] = base64.b64decode(data_tag.text.strip())
+                    dub['_embedded_format'] = data_tag.attrs.get('format', 'wav')
+                    self.has_embedded_audio_clips = True
+                except Exception:
+                    pass
+            dubs.append(dub)
+        if dubs:
+            subtitle['dubbing'] = dubs
+
+        return subtitle
+
+
+class USFWriter():
+    """USFWriter class"""
+    def __init__(self, *args, **kwargs):
+        super(USFWriter, self).__init__(*args, **kwargs)
+
+    def write(self, subtitles, speakers=None, language=None, metadata=None,
+              embed_audio_clips=False):
+        """Serialize subtitles to USF XML.
+
+        Parameters:
+          subtitles: list of subtitle dicts (from session.SUBTITLE['segments']).
+          speakers:  dict name -> {'color': '#RRGGBB', 'image_bytes': bytes, ...}.
+                     Emits one <style> per speaker; writes `speaker` + `style` on
+                     <text>. If a speaker has `image_bytes`, embeds it inside the
+                     <style> as <avatar encoding="base64" format="png">…</avatar>.
+          language:  ISO language code for the primary <subtitles> block.
+          metadata:  dict with optional 'title', 'author', 'date' keys.
+          embed_audio_clips: if True, reads each dub's WAV file from disk and
+                     embeds base64 bytes as <data encoding="base64"> inside the
+                     <dubbing> element.
+        """
+        speakers = speakers or {}
+        metadata = metadata or {}
+
+        usf = BeautifulSoup(USF_BASE_MARKUP, 'lxml-xml')
+
+        meta_tag = usf.find('metadata')
+        if 'title' in metadata:
+            title = usf.new_tag('title')
+            title.string = str(metadata['title'])
+            meta_tag.append(title)
+        author = usf.new_tag('author')
+        name = usf.new_tag('name')
+        name.string = str(metadata.get('author', 'Subtitld'))
+        author.append(name)
+        meta_tag.append(author)
+        if language:
+            lang_tag = usf.new_tag('language')
+            lang_tag['code'] = language
+            meta_tag.append(lang_tag)
+        if 'date' in metadata:
+            date = usf.new_tag('date')
+            date.string = str(metadata['date'])
+            meta_tag.append(date)
+
+        styles_tag = usf.find('styles')
+
+        default_style = usf.new_tag('style')
+        default_style['name'] = 'Default'
+        default_fontstyle = usf.new_tag('fontstyle', color='#EEEEFF', face='Arial', size='24', family='Arial')
+        default_fontstyle['outline-color'] = '#5555FF'
+        default_style.append(default_fontstyle)
+        default_position = usf.new_tag('position', alignment='BottomCenter')
+        default_position['relative-to'] = 'Window'
+        default_position['vertical-margin'] = '10%'
+        default_style.append(default_position)
+        styles_tag.append(default_style)
+
+        for speaker_name, speaker_data in speakers.items():
+            if speaker_name == 'Default':
+                continue
+            style = usf.new_tag('style')
+            style['name'] = speaker_name
+            color = speaker_data.get('color') if isinstance(speaker_data, dict) else None
+            if color:
+                fontstyle = usf.new_tag('fontstyle')
+                fontstyle['color'] = color
+                style.append(fontstyle)
+            image_bytes = speaker_data.get('image_bytes') if isinstance(speaker_data, dict) else None
+            if image_bytes:
+                avatar = usf.new_tag('avatar')
+                avatar['encoding'] = 'base64'
+                avatar['format'] = 'png'
+                avatar.string = base64.b64encode(image_bytes).decode('ascii')
+                style.append(avatar)
+            dubbing_settings = speaker_data.get('dubbing') if isinstance(speaker_data, dict) else None
+            if isinstance(dubbing_settings, dict):
+                dub_tag = usf.new_tag('dubbing')
+                for key in ('engine', 'voice'):
+                    val = dubbing_settings.get(key)
+                    if val:
+                        dub_tag[key] = str(val)
+                for key in ('rate', 'pitch'):
+                    val = dubbing_settings.get(key)
+                    if val is not None:
+                        dub_tag[key] = str(val)
+                if dub_tag.attrs:
+                    style.append(dub_tag)
+            styles_tag.append(style)
+
+        primary = usf.new_tag('subtitles')
+        if language:
+            lang_tag = usf.new_tag('language')
+            lang_tag['code'] = language
+            primary.append(lang_tag)
+        usf.find('USFSubtitles').append(primary)
+
+        for subtitle in subtitles:
+            primary.append(self._build_subtitle(usf, subtitle, speakers, embed_audio_clips=embed_audio_clips))
+
+        translation_languages = []
+        for subtitle in subtitles:
+            for lang in subtitle.get('translations', {}):
+                if lang and lang not in translation_languages and lang != language:
+                    translation_languages.append(lang)
+
+        for tr_lang in translation_languages:
+            block = usf.new_tag('subtitles')
+            lang_tag = usf.new_tag('language')
+            lang_tag['code'] = tr_lang
+            block.append(lang_tag)
+            for subtitle in subtitles:
+                block.append(self._build_subtitle(
+                    usf,
+                    subtitle,
+                    speakers,
+                    text_override=subtitle.get('translations', {}).get(tr_lang, ''),
+                    include_dubs=False,
+                ))
+            usf.find('USFSubtitles').append(block)
+
+        return str(usf)
+
+    def _build_subtitle(self, usf, subtitle, speakers, text_override=None, include_dubs=True, embed_audio_clips=False):
+        new_sub = usf.new_tag(
+            'subtitle',
+            start=str(timecode.Timecode('1000', start_seconds=subtitle['start'], fractional=True)),
+            stop=str(timecode.Timecode('1000', start_seconds=subtitle['end'], fractional=True)),
+        )
+
+        text_tag = usf.new_tag('text')
+        speaker = subtitle.get('speaker', 'A')
+        if speaker:
+            text_tag['speaker'] = speaker
+            if speaker in speakers:
+                text_tag['style'] = speaker
+
+        text_value = subtitle.get('text', '') if text_override is None else text_override
+        self._append_text_with_breaks(usf, text_tag, text_value)
+        new_sub.append(text_tag)
+
+        if include_dubs:
+            for dub in subtitle.get('dubbing', []):
+                dub_tag = usf.new_tag('dubbing')
+                for key in ('engine', 'path', 'uid'):
+                    if key in dub and dub[key] is not None:
+                        dub_tag[key] = str(dub[key])
+                for key in ('start', 'end', 'rate', 'pitch'):
+                    if key in dub and dub[key] is not None:
+                        dub_tag[key] = str(dub[key])
+                if embed_audio_clips:
+                    path = dub.get('path')
+                    if path and os.path.isfile(path):
+                        try:
+                            with open(path, 'rb') as f:
+                                raw = f.read()
+                            data_tag = usf.new_tag('data')
+                            data_tag['encoding'] = 'base64'
+                            data_tag['format'] = os.path.splitext(path)[1].lstrip('.').lower() or 'wav'
+                            data_tag.string = base64.b64encode(raw).decode('ascii')
+                            dub_tag.append(data_tag)
+                        except Exception:
+                            pass
+                new_sub.append(dub_tag)
+
+        return new_sub
+
+    def _append_text_with_breaks(self, usf, text_tag, value):
+        if not value:
+            return
+        lines = str(value).split('\n')
+        for idx, line in enumerate(lines):
+            if idx:
+                text_tag.append(usf.new_tag('br'))
+            if line:
+                text_tag.append(NavigableString(line))

subtitld/modules/utils.py

@@ -0,0 +1,79 @@
+import os
+import hashlib
+
+from subtitld.modules import session
+
+
+def is_float(element: str) -> bool:
+    try:
+        float(element)
+        return True
+    except ValueError:
+        return False
+
+
+def get_timeline_time_str(seconds, ms=False):
+    """Function to return timecode from seconds"""
+    secs = int(seconds % 60)
+    mins = int((seconds / 60) % 60)
+    hrs = int((seconds / 60) / 60)
+    mss = int(round(float('0.' + str(seconds).split('.', 1)[-1]), 3) * 1000)
+
+    if ms:
+        if hrs:
+            return "{hh:02d}:{mm:02d}:{ss:02d}.{mss:03d}".format(hh=hrs, mm=mins, ss=secs, mss=mss)
+        elif mins:
+            return "{mm:02d}:{ss:02d}.{mss:03d}".format(mm=mins, ss=secs, mss=mss)
+        else:
+            return "{ss:02d}.{mss:03d}".format(ss=secs, mss=mss)
+    else:
+        if hrs:
+            return "{hh:02d}:{mm:02d}:{ss:02d}".format(hh=hrs, mm=mins, ss=secs)
+        elif mins:
+            return "{mm:02d}:{ss:02d}".format(mm=mins, ss=secs)
+        else:
+            return "{ss:02d}".format(ss=secs)
+
+
+def convert_ffmpeg_timecode_to_seconds(timecode):
+    """Function to convert ffmpeg timecode to seconds"""
+    if timecode:
+        final_value = float(timecode.split(':')[-1])
+        if timecode.count(':') > 2:
+            final_value += int(timecode.split(':')[-2]) * 60.0
+        if timecode.count(':') > 3:
+            final_value += int(timecode.split(':')[-3]) * 3600.0
+        if timecode.count(':') > 4:
+            final_value += int(timecode.split(':')[-4]) * 3600.0
+        return final_value
+    else:
+        return False
+
+
+def get_subtitle_format(subtitle_filepath):
+    subtitle_format = False
+    if subtitle_filepath:
+        for formt in session.LIST_OF_SUPPORTED_SUBTITLE_EXTENSIONS:
+            for ext in session.LIST_OF_SUPPORTED_SUBTITLE_EXTENSIONS[formt]['extensions']:
+                if subtitle_filepath.endswith(ext):
+                    subtitle_format = formt
+    return subtitle_format
+
+
+def get_format_from_extension(extension):
+    for format in session.LIST_OF_SUPPORTED_SUBTITLE_EXTENSIONS:
+        for ext in session.LIST_OF_SUPPORTED_SUBTITLE_EXTENSIONS[format]['extensions']:
+            if extension == ext:
+                return format
+    return 'USF'
+
+
+def get_cache_key(filepath):
+    """Generate a cache key based on file path, size and modification time."""
+    try:
+        stat = os.stat(filepath)
+        file_info = f"{filepath}|{stat.st_size}|{stat.st_mtime}"
+        hash_key = hashlib.md5(file_info.encode()).hexdigest()
+        return hash_key
+    except Exception:
+        return None

subtitld/modules/waveform.py

@@ -0,0 +1,53 @@
+"""Waveform module
+
+"""
+
+import os
+import subprocess
+import json
+
+from subtitld.modules.session import STARTUPINFO, FFMPEG_EXECUTABLE, PATH_TEMP, FFPROBE_EXECUTABLE
+
+
+def ffmpeg_extract_subtitle(filepath, index):
+    """Function to extract subtitle from video using ffmpeg"""
+    command = [
+        FFMPEG_EXECUTABLE,
+        '-i',
+        filepath,
+        '-map',
+        '0:' + str(index),
+        os.path.join(PATH_TEMP, 'subtitle.vtt')]
+    subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        startupinfo=STARTUPINFO
+    ).wait()
+    return os.path.join(PATH_TEMP, 'subtitle.vtt')
+
+
+def ffmpeg_load_metadata(filepath):
+    """Function to read video's metadata"""
+    command = [
+        FFPROBE_EXECUTABLE,
+        '-v',
+        'quiet',
+        '-print_format',
+        'json',
+        '-show_format',
+        '-show_streams',
+        filepath]
+    proc = subprocess.Popen(
+        command, 
+        stdout=subprocess.PIPE, 
+        stderr=subprocess.DEVNULL, 
+        startupinfo=STARTUPINFO
+    )
+    json_file = False
+    with proc.stdout as stdout:
+        json_file = json.loads(stdout.read())
+
+    return json_file
+
+

subtitld-0.0.0.dev0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: subtitld
+Version: 0.0.0.dev0
+Summary: Subtitld
+Author-email: Jonatã Bolzan Loss <subtitld@subtitld.org>
+License: GPL3
+Project-URL: Homepage, https://subtitld.org
+Project-URL: Issues, https://gitlab.com/jonata/subtitld/issues
+Keywords: subtitld
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: X11 Applications :: Qt
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Natural Language :: English
+Classifier: Operating System :: POSIX
+Classifier: Topic :: Multimedia
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PySide6==6.10.0
+Requires-Dist: PySideSix-Frameless-Window
+Requires-Dist: mediapipe==0.10.21
+Requires-Dist: opencv-python
+Requires-Dist: python-i18n
+Requires-Dist: python-docx
+Requires-Dist: pycaption
+Requires-Dist: chardet==6.0.0
+Requires-Dist: pysubs2
+Requires-Dist: translate
+Requires-Dist: autohex
+Requires-Dist: platformdirs
+Requires-Dist: psutil
+Requires-Dist: vosk
+Requires-Dist: assemblyai
+Requires-Dist: deep_translator
+Requires-Dist: soundfile
+Requires-Dist: edge-tts
+Provides-Extra: transcribe
+Requires-Dist: vosk; extra == "transcribe"
+Requires-Dist: assemblyai; extra == "transcribe"
+Provides-Extra: translate
+Requires-Dist: translate; extra == "translate"
+Requires-Dist: deep_translator; extra == "translate"
+Provides-Extra: vision
+Requires-Dist: mediapipe==0.10.21; extra == "vision"
+Requires-Dist: opencv-python; extra == "vision"
+Provides-Extra: dub
+Requires-Dist: edge-tts; extra == "dub"
+Provides-Extra: all
+Requires-Dist: vosk; extra == "all"
+Requires-Dist: assemblyai; extra == "all"
+Requires-Dist: translate; extra == "all"
+Requires-Dist: deep_translator; extra == "all"
+Requires-Dist: mediapipe==0.10.21; extra == "all"
+Requires-Dist: opencv-python; extra == "all"
+Requires-Dist: edge-tts; extra == "all"
+Dynamic: license-file
+
+# Subtitld
+
+Subtitld is a software to create, edit and transcribe subtitles.
+
+## Installation
+
+```bash
+pip install subtitld
+```
+
+## Requirements
+
+Subtitld uses `ffmpeg` for internal processes.
+
+On Ubuntu/Debian:
+```bash
+sudo apt install ffmpeg
+```
+
+## Usage
+
+```bash
+subtitld
+```
+
+Or with a file:
+```bash
+subtitld video.mp4
+```
+
+## License
+
+GPL3 - see LICENSE file for details
+
+## Links
+
+- Homepage: https://subtitld.org
+- Issues: https://gitlab.com/jonata/subtitld/issues