supervertaler 1.9.163__py3-none-any.whl

modules/tag_cleaner.py

@@ -0,0 +1,260 @@
+"""
+TagCleaner Module for Supervertaler
+Removes CAT tool tags from translation text
+
+Supports tags from:
+- memoQ
+- Trados Studio
+- CafeTran
+- Wordfast
+
+Can be used standalone or integrated with other modules like AutoFingers.
+"""
+
+import re
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class TagPattern:
+    """Definition of a tag pattern to clean"""
+    name: str
+    description: str
+    pattern: str  # Regex pattern
+    enabled: bool = True
+
+
+class TagCleaner:
+    """
+    Removes CAT tool tags from translation text.
+
+    Usage:
+        cleaner = TagCleaner()
+        cleaner.enable_memoq_index_tags()
+        cleaned = cleaner.clean("Text with [1}tags{2] here")
+    """
+
+    def __init__(self):
+        """Initialize TagCleaner with all available tag patterns."""
+        self.enabled = False  # Master switch
+
+        # memoQ tag patterns
+        self.memoq_patterns: Dict[str, TagPattern] = {
+            "index_tags": TagPattern(
+                name="memoQ Index Tags",
+                description="Index tags like [1} {2] [3} {4] etc.",
+                pattern=r'(?:\[\d+\}|\{\d+\])',
+                enabled=True
+            ),
+            # Add more memoQ tag types here as needed
+        }
+
+        # Trados Studio tag patterns (placeholders for future)
+        self.trados_patterns: Dict[str, TagPattern] = {
+            # TODO: Add Trados tag patterns
+        }
+
+        # CafeTran tag patterns (placeholders for future)
+        self.cafetran_patterns: Dict[str, TagPattern] = {
+            # TODO: Add CafeTran tag patterns
+        }
+
+        # Wordfast tag patterns (placeholders for future)
+        self.wordfast_patterns: Dict[str, TagPattern] = {
+            # TODO: Add Wordfast tag patterns
+        }
+
+    def enable(self) -> None:
+        """Enable tag cleaning (master switch)."""
+        self.enabled = True
+
+    def disable(self) -> None:
+        """Disable tag cleaning (master switch)."""
+        self.enabled = False
+
+    def is_enabled(self) -> bool:
+        """Check if tag cleaning is enabled."""
+        return self.enabled
+
+    # memoQ tag control methods
+    def enable_memoq_index_tags(self) -> None:
+        """Enable cleaning of memoQ index tags ([1} {2] etc.)."""
+        if "index_tags" in self.memoq_patterns:
+            self.memoq_patterns["index_tags"].enabled = True
+
+    def disable_memoq_index_tags(self) -> None:
+        """Disable cleaning of memoQ index tags."""
+        if "index_tags" in self.memoq_patterns:
+            self.memoq_patterns["index_tags"].enabled = False
+
+    def is_memoq_index_tags_enabled(self) -> bool:
+        """Check if memoQ index tag cleaning is enabled."""
+        return self.memoq_patterns.get("index_tags", TagPattern("", "", "", False)).enabled
+
+    # Generic pattern management
+    def add_custom_pattern(self, category: str, key: str, pattern: TagPattern) -> None:
+        """
+        Add a custom tag pattern.
+
+        Args:
+            category: Category name ("memoq", "trados", "cafetran", "wordfast")
+            key: Unique identifier for this pattern
+            pattern: TagPattern to add
+        """
+        category_map = {
+            "memoq": self.memoq_patterns,
+            "trados": self.trados_patterns,
+            "cafetran": self.cafetran_patterns,
+            "wordfast": self.wordfast_patterns,
+        }
+
+        if category.lower() in category_map:
+            category_map[category.lower()][key] = pattern
+
+    def remove_pattern(self, category: str, key: str) -> None:
+        """Remove a tag pattern."""
+        category_map = {
+            "memoq": self.memoq_patterns,
+            "trados": self.trados_patterns,
+            "cafetran": self.cafetran_patterns,
+            "wordfast": self.wordfast_patterns,
+        }
+
+        if category.lower() in category_map:
+            category_map[category.lower()].pop(key, None)
+
+    def get_all_patterns(self) -> List[TagPattern]:
+        """Get all tag patterns from all categories."""
+        all_patterns = []
+        all_patterns.extend(self.memoq_patterns.values())
+        all_patterns.extend(self.trados_patterns.values())
+        all_patterns.extend(self.cafetran_patterns.values())
+        all_patterns.extend(self.wordfast_patterns.values())
+        return all_patterns
+
+    def get_enabled_patterns(self) -> List[TagPattern]:
+        """Get only enabled tag patterns."""
+        return [p for p in self.get_all_patterns() if p.enabled]
+
+    def clean(self, text: str) -> str:
+        """
+        Remove tags from text based on enabled patterns.
+
+        Args:
+            text: Text potentially containing CAT tool tags
+
+        Returns:
+            Text with enabled tags removed
+        """
+        if not self.enabled or not text:
+            return text
+
+        cleaned_text = text
+
+        # Apply all enabled patterns
+        for pattern in self.get_enabled_patterns():
+            cleaned_text = re.sub(pattern.pattern, '', cleaned_text)
+
+        return cleaned_text
+
+    def preview_cleaning(self, text: str) -> Dict[str, str]:
+        """
+        Preview what text would look like with each pattern applied.
+
+        Args:
+            text: Text to preview cleaning on
+
+        Returns:
+            Dictionary mapping pattern names to cleaned text
+        """
+        previews = {}
+
+        for pattern in self.get_all_patterns():
+            if pattern.enabled:
+                cleaned = re.sub(pattern.pattern, '', text)
+                previews[pattern.name] = cleaned
+
+        return previews
+
+    def to_dict(self) -> Dict:
+        """
+        Export settings to dictionary (for JSON serialization).
+
+        Returns:
+            Dictionary with all tag cleaner settings
+        """
+        return {
+            "enabled": self.enabled,
+            "memoq": {
+                key: {"enabled": pattern.enabled}
+                for key, pattern in self.memoq_patterns.items()
+            },
+            "trados": {
+                key: {"enabled": pattern.enabled}
+                for key, pattern in self.trados_patterns.items()
+            },
+            "cafetran": {
+                key: {"enabled": pattern.enabled}
+                for key, pattern in self.cafetran_patterns.items()
+            },
+            "wordfast": {
+                key: {"enabled": pattern.enabled}
+                for key, pattern in self.wordfast_patterns.items()
+            },
+        }
+
+    def from_dict(self, settings: Dict) -> None:
+        """
+        Import settings from dictionary.
+
+        Args:
+            settings: Dictionary with tag cleaner settings
+        """
+        self.enabled = settings.get("enabled", False)
+
+        # Load memoQ pattern states
+        memoq_settings = settings.get("memoq", {})
+        for key, pattern_settings in memoq_settings.items():
+            if key in self.memoq_patterns:
+                self.memoq_patterns[key].enabled = pattern_settings.get("enabled", True)
+
+        # Load Trados pattern states
+        trados_settings = settings.get("trados", {})
+        for key, pattern_settings in trados_settings.items():
+            if key in self.trados_patterns:
+                self.trados_patterns[key].enabled = pattern_settings.get("enabled", False)
+
+        # Load CafeTran pattern states
+        cafetran_settings = settings.get("cafetran", {})
+        for key, pattern_settings in cafetran_settings.items():
+            if key in self.cafetran_patterns:
+                self.cafetran_patterns[key].enabled = pattern_settings.get("enabled", False)
+
+        # Load Wordfast pattern states
+        wordfast_settings = settings.get("wordfast", {})
+        for key, pattern_settings in wordfast_settings.items():
+            if key in self.wordfast_patterns:
+                self.wordfast_patterns[key].enabled = pattern_settings.get("enabled", False)
+
+
+# Standalone usage example
+if __name__ == "__main__":
+    # Create cleaner
+    cleaner = TagCleaner()
+
+    # Enable tag cleaning
+    cleaner.enable()
+
+    # Enable specific tag types
+    cleaner.enable_memoq_index_tags()
+
+    # Test text
+    test_text = "Laat de tractor nooit draaien in een afgesloten ruimte, tenzij de uitlaat naar buiten wordt afgevoerd [7}lucht.{8]"
+
+    # Clean tags
+    cleaned = cleaner.clean(test_text)
+
+    print(f"Original: {test_text}")
+    print(f"Cleaned:  {cleaned}")
+    print(f"\nExpected: Laat de tractor nooit draaien in een afgesloten ruimte, tenzij de uitlaat naar buiten wordt afgevoerd lucht.")

modules/tag_manager.py

@@ -0,0 +1,351 @@
+"""
+Tag Manager
+Handle inline formatting tags (bold, italic, underline)
+
+This module converts formatting runs into XML-like tags for editing,
+validates tag integrity, and reconstructs formatting on export.
+
+Example:
+    "This is **bold** text" → "This is <b>bold</b> text"
+"""
+
+from typing import List, Tuple, Dict, Any
+from dataclasses import dataclass
+import re
+
+
+@dataclass
+class FormattingRun:
+    """Represents a formatting run in text"""
+    text: str
+    bold: bool = False
+    italic: bool = False
+    underline: bool = False
+    subscript: bool = False
+    superscript: bool = False
+    start_pos: int = 0
+    end_pos: int = 0
+    
+    def has_formatting(self) -> bool:
+        """Check if this run has any formatting"""
+        return self.bold or self.italic or self.underline or self.subscript or self.superscript
+    
+    def get_tag_name(self) -> str:
+        """Get the tag name for this formatting"""
+        if self.bold and self.italic:
+            return "bi"
+        elif self.bold:
+            return "b"
+        elif self.italic:
+            return "i"
+        elif self.underline:
+            return "u"
+        elif self.subscript:
+            return "sub"
+        elif self.superscript:
+            return "sup"
+        return None
+
+
+class TagManager:
+    """Manage inline formatting tags"""
+    
+    # Tag patterns - includes list item tags and sub/sup
+    TAG_PATTERN = re.compile(r'<(/?)([biu]|bi|li|sub|sup)>')
+    
+    def __init__(self):
+        self.tag_colors = {
+            'b': '#CC0000',    # Red for bold
+            'i': '#0066CC',    # Blue for italic
+            'u': '#009900',    # Green for underline
+            'bi': '#CC00CC',   # Purple for bold+italic
+            'li': '#FF6600',   # Orange for list items
+            'sub': '#666600',  # Olive for subscript
+            'sup': '#006666'   # Teal for superscript
+        }
+    
+    def extract_runs(self, paragraph) -> List[FormattingRun]:
+        """
+        Extract formatting runs from a python-docx paragraph
+        
+        Args:
+            paragraph: python-docx paragraph object
+            
+        Returns:
+            List of FormattingRun objects with position information
+        """
+        runs = []
+        current_pos = 0
+        
+        # Check if paragraph style has bold/italic formatting
+        # This handles cases like "Subtitle" or "Title" styles that are bold
+        style_bold = False
+        style_italic = False
+        try:
+            if paragraph.style and paragraph.style.font:
+                if paragraph.style.font.bold:
+                    style_bold = True
+                if paragraph.style.font.italic:
+                    style_italic = True
+        except Exception:
+            pass  # If we can't read style, just use run-level formatting
+        
+        for run in paragraph.runs:
+            text = run.text
+            if not text:
+                continue
+            
+            # Combine run-level formatting with style-level formatting
+            # run.bold can be True, False, or None (None means inherit from style)
+            is_bold = run.bold if run.bold is not None else style_bold
+            is_italic = run.italic if run.italic is not None else style_italic
+            
+            run_info = FormattingRun(
+                text=text,
+                bold=is_bold or False,
+                italic=is_italic or False,
+                underline=run.underline or False,
+                subscript=run.font.subscript or False if run.font else False,
+                superscript=run.font.superscript or False if run.font else False,
+                start_pos=current_pos,
+                end_pos=current_pos + len(text)
+            )
+            runs.append(run_info)
+            current_pos += len(text)
+        
+        return runs
+    
+    def runs_to_tagged_text(self, runs: List[FormattingRun]) -> str:
+        """
+        Convert formatting runs to tagged text
+        
+        Example:
+            [Run("Hello ", bold=False), Run("world", bold=True), Run("!", bold=False)]
+            → "Hello <b>world</b>!"
+        
+        Args:
+            runs: List of FormattingRun objects
+            
+        Returns:
+            Text with inline tags
+        """
+        if not runs:
+            return ""
+        
+        result = []
+        current_formatting = {'bold': False, 'italic': False, 'underline': False, 'subscript': False, 'superscript': False}
+        
+        for run in runs:
+            # Determine what formatting changed
+            formatting_changed = (
+                run.bold != current_formatting['bold'] or
+                run.italic != current_formatting['italic'] or
+                run.underline != current_formatting['underline'] or
+                run.subscript != current_formatting['subscript'] or
+                run.superscript != current_formatting['superscript']
+            )
+            
+            if formatting_changed:
+                # Close previous tags (in reverse order of nesting)
+                if current_formatting['subscript']:
+                    result.append('</sub>')
+                if current_formatting['superscript']:
+                    result.append('</sup>')
+                if current_formatting['bold'] and current_formatting['italic']:
+                    result.append('</bi>')
+                elif current_formatting['bold']:
+                    result.append('</b>')
+                elif current_formatting['italic']:
+                    result.append('</i>')
+                elif current_formatting['underline']:
+                    result.append('</u>')
+                
+                # Open new tags
+                if run.bold and run.italic:
+                    result.append('<bi>')
+                elif run.bold:
+                    result.append('<b>')
+                elif run.italic:
+                    result.append('<i>')
+                elif run.underline:
+                    result.append('<u>')
+                if run.subscript:
+                    result.append('<sub>')
+                if run.superscript:
+                    result.append('<sup>')
+                
+                # Update current state
+                current_formatting['bold'] = run.bold
+                current_formatting['italic'] = run.italic
+                current_formatting['underline'] = run.underline
+                current_formatting['subscript'] = run.subscript
+                current_formatting['superscript'] = run.superscript
+            
+            result.append(run.text)
+        
+        # Close any remaining tags
+        if current_formatting['subscript']:
+            result.append('</sub>')
+        if current_formatting['superscript']:
+            result.append('</sup>')
+        if current_formatting['bold'] and current_formatting['italic']:
+            result.append('</bi>')
+        elif current_formatting['bold']:
+            result.append('</b>')
+        elif current_formatting['italic']:
+            result.append('</i>')
+        elif current_formatting['underline']:
+            result.append('</u>')
+        
+        return ''.join(result)
+    
+    def tagged_text_to_runs(self, text: str) -> List[Dict[str, Any]]:
+        """
+        Convert tagged text back to run specifications
+        
+        Example:
+            "Hello <b>world</b>!" →
+            [{'text': 'Hello ', 'bold': False},
+             {'text': 'world', 'bold': True},
+             {'text': '!', 'bold': False}]
+        
+        Args:
+            text: Text with inline tags
+            
+        Returns:
+            List of run specifications (dicts with text and formatting)
+        """
+        runs = []
+        current_formatting = {'bold': False, 'italic': False, 'underline': False, 'subscript': False, 'superscript': False}
+        current_text = []
+        
+        pos = 0
+        while pos < len(text):
+            # Check for tag
+            match = self.TAG_PATTERN.match(text, pos)
+            if match:
+                # Save current text as a run
+                if current_text:
+                    runs.append({
+                        'text': ''.join(current_text),
+                        'bold': current_formatting['bold'],
+                        'italic': current_formatting['italic'],
+                        'underline': current_formatting['underline'],
+                        'subscript': current_formatting['subscript'],
+                        'superscript': current_formatting['superscript']
+                    })
+                    current_text = []
+                
+                # Process tag
+                is_closing = match.group(1) == '/'
+                tag_name = match.group(2)
+                
+                if tag_name == 'bi':
+                    current_formatting['bold'] = not is_closing
+                    current_formatting['italic'] = not is_closing
+                elif tag_name == 'b':
+                    current_formatting['bold'] = not is_closing
+                elif tag_name == 'i':
+                    current_formatting['italic'] = not is_closing
+                elif tag_name == 'u':
+                    current_formatting['underline'] = not is_closing
+                elif tag_name == 'sub':
+                    current_formatting['subscript'] = not is_closing
+                elif tag_name == 'sup':
+                    current_formatting['superscript'] = not is_closing
+                
+                pos = match.end()
+            else:
+                # Regular character
+                current_text.append(text[pos])
+                pos += 1
+        
+        # Save final text
+        if current_text:
+            runs.append({
+                'text': ''.join(current_text),
+                'bold': current_formatting['bold'],
+                'italic': current_formatting['italic'],
+                'underline': current_formatting['underline'],
+                'subscript': current_formatting['subscript'],
+                'superscript': current_formatting['superscript']
+            })
+        
+        return runs
+    
+    def validate_tags(self, text: str) -> Tuple[bool, str]:
+        """
+        Validate that all tags are properly paired and nested
+        
+        Args:
+            text: Text with inline tags
+            
+        Returns:
+            (is_valid, error_message)
+        """
+        stack = []
+        pos = 0
+        
+        while pos < len(text):
+            match = self.TAG_PATTERN.match(text, pos)
+            if match:
+                is_closing = match.group(1) == '/'
+                tag_name = match.group(2)
+                
+                if is_closing:
+                    if not stack:
+                        return False, f"Closing tag </{tag_name}> without opening tag"
+                    if stack[-1] != tag_name:
+                        return False, f"Mismatched tags: expected </{stack[-1]}>, found </{tag_name}>"
+                    stack.pop()
+                else:
+                    stack.append(tag_name)
+                
+                pos = match.end()
+            else:
+                pos += 1
+        
+        if stack:
+            return False, f"Unclosed tags: {', '.join(stack)}"
+        
+        return True, ""
+    
+    def count_tags(self, text: str) -> Dict[str, int]:
+        """
+        Count tags in text
+        
+        Returns:
+            Dictionary with tag counts (e.g., {'b': 2, 'i': 1})
+        """
+        counts = {}
+        pos = 0
+        
+        while pos < len(text):
+            match = self.TAG_PATTERN.match(text, pos)
+            if match:
+                is_closing = match.group(1) == '/'
+                if not is_closing:  # Only count opening tags
+                    tag_name = match.group(2)
+                    counts[tag_name] = counts.get(tag_name, 0) + 1
+                pos = match.end()
+            else:
+                pos += 1
+        
+        return counts
+    
+    def strip_tags(self, text: str) -> str:
+        """Remove all tags from text"""
+        return self.TAG_PATTERN.sub('', text)
+    
+    def get_tag_color(self, tag_name: str) -> str:
+        """Get color for tag name"""
+        return self.tag_colors.get(tag_name, '#000000')
+    
+    def format_for_display(self, text: str) -> str:
+        """
+        Format tagged text for display (simplified version)
+        This could be enhanced with colored markers in a rich text widget
+        
+        For now, just show tags as-is
+        """
+        return text