supervertaler 1.9.153__py3-none-any.whl

modules/statuses.py

@@ -0,0 +1,207 @@
+"""Centralized status vocabulary for Supervertaler segments."""
+
+from dataclasses import dataclass
+from typing import Dict, Optional
+import re
+
+
+@dataclass(frozen=True)
+class StatusDefinition:
+    key: str
+    label: str
+    icon: str
+    color: str
+    memoq_label: str
+    memoQ_equivalents: tuple[str, ...]
+    match_symbol: str = ""
+
+
+STATUSES: Dict[str, StatusDefinition] = {
+    "not_started": StatusDefinition(
+        key="not_started",
+        label="Not started",
+        icon="❌",  # Red X - clear "not done" indicator (matches memoQ style)
+        color="#ffe6e6",
+        memoq_label="Not started",
+        memoQ_equivalents=("not started", "not translated"),
+    ),
+    "pretranslated": StatusDefinition(
+        key="pretranslated",
+        label="Pre-translated",
+        icon="🤖",  # Robot - indicates automatic/machine pre-translation
+        color="#e8f2ff",
+        memoq_label="Pre-translated",
+        memoQ_equivalents=("pre-translated", "pretranslated"),
+        match_symbol="⚡",
+    ),
+    "translated": StatusDefinition(
+        key="translated",
+        label="Translated",
+        icon="✏️",  # Pencil - indicates manual translation work (matches Trados style)
+        color="#e6ffe6",
+        memoq_label="Translated",
+        memoQ_equivalents=("translated",),
+        match_symbol="✍️",
+    ),
+    "confirmed": StatusDefinition(
+        key="confirmed",
+        label="Confirmed",
+        icon="✔",  # Checkmark - will be styled green via CSS
+        color="#d1ffd6",
+        memoq_label="Confirmed",
+        memoQ_equivalents=("confirmed",),
+        match_symbol="🛡️",
+    ),
+    "tr_confirmed": StatusDefinition(
+        key="tr_confirmed",
+        label="TR confirmed",
+        icon="🌟",
+        color="#d9f0ff",
+        memoq_label="TR confirmed",
+        memoQ_equivalents=("tr confirmed", "translation review confirmed"),
+        match_symbol="🌐",
+    ),
+    "proofread": StatusDefinition(
+        key="proofread",
+        label="Proofread",
+        icon="🟪",
+        color="#efe0ff",
+        memoq_label="Proofread",
+        memoQ_equivalents=("proofread",),
+        match_symbol="📘",
+    ),
+    "rejected": StatusDefinition(
+        key="rejected",
+        label="Rejected",
+        icon="🚫",
+        color="#ffe0e0",
+        memoq_label="Rejected",
+        memoQ_equivalents=("rejected",),
+        match_symbol="⛔",
+    ),
+    "approved": StatusDefinition(
+        key="approved",
+        label="Approved",
+        icon="⭐",
+        color="#e6f3ff",
+        memoq_label="Approved",
+        memoQ_equivalents=("approved", "final", "proofread confirmed"),
+        match_symbol="🏁",
+    ),
+    "pm": StatusDefinition(
+        key="pm",
+        label="PM (102%)",
+        icon="⭐",  # Star - perfect/double context match
+        color="#b8daff",  # Light blue - highest confidence
+        memoq_label="Pre-translated (102%)",
+        memoQ_equivalents=("pre-translated (102%)", "102%", "xlt", "double context", "perfect match", "pm"),
+        match_symbol="⭐",
+    ),
+    "cm": StatusDefinition(
+        key="cm",
+        label="CM (101%)",
+        icon="💎",  # Diamond - context match
+        color="#c3e6cb",  # Darker green - very high confidence
+        memoq_label="Pre-translated (101%)",
+        memoQ_equivalents=("pre-translated (101%)", "context match", "cm", "101%"),
+        match_symbol="💎",
+    ),
+    "tm_100": StatusDefinition(
+        key="tm_100",
+        label="TM 100%",
+        icon="✅",  # Checkmark - exact match
+        color="#d4edda",  # Light green - high confidence
+        memoq_label="Pre-translated (100%)",
+        memoQ_equivalents=("pre-translated (100%)", "100%", "exact match"),
+        match_symbol="✅",
+    ),
+    "tm_fuzzy": StatusDefinition(
+        key="tm_fuzzy",
+        label="TM Fuzzy",
+        icon="🔶",  # Orange diamond - partial match
+        color="#fff3cd",  # Light yellow/orange - needs review
+        memoq_label="Pre-translated (fuzzy)",
+        memoQ_equivalents=("fuzzy", "fuzzy match"),
+        match_symbol="🔶",
+    ),
+    "repetition": StatusDefinition(
+        key="repetition",
+        label="Repetition",
+        icon="🔁",  # Repeat icon - internal repetition
+        color="#e2e3e5",  # Light gray - auto-propagated
+        memoq_label="Repetition",
+        memoQ_equivalents=("repetition", "rep", "auto-propagated"),
+        match_symbol="🔁",
+    ),
+    "machine_translated": StatusDefinition(
+        key="machine_translated",
+        label="MT",
+        icon="🤖",  # Robot - machine translation
+        color="#ffeaa7",  # Light orange/yellow - needs review
+        memoq_label="Machine Translated",
+        memoQ_equivalents=("machine translated", "mt", "nmt", "auto-translated"),
+        match_symbol="🤖",
+    ),
+}
+
+DEFAULT_STATUS = STATUSES["not_started"]
+
+
+def get_status(key: str) -> StatusDefinition:
+    """Return status definition for key, falling back to default."""
+    return STATUSES.get(key, DEFAULT_STATUS)
+
+
+def match_memoq_status(status_text: str) -> tuple[StatusDefinition, Optional[int]]:
+    """Map memoQ status string to a StatusDefinition plus optional match percent."""
+    status_clean = (status_text or "").strip()
+    percent: Optional[int] = None
+
+    if status_clean:
+        match = re.search(r"(\d+)\s*%", status_clean)
+        if match:
+            try:
+                percent = int(match.group(1))
+            except ValueError:
+                percent = None
+
+    lower = status_clean.lower()
+
+    for definition in STATUSES.values():
+        if any(eq in lower for eq in definition.memoQ_equivalents):
+            return definition, percent
+
+    if "proofread" in lower and "confirm" in lower:
+        return STATUSES["approved"], percent
+    if "confirm" in lower and "tr" in lower:
+        return STATUSES["tr_confirmed"], percent
+    if "confirm" in lower:
+        return STATUSES["confirmed"], percent
+    if "lock" in lower:
+        return STATUSES["not_started"], percent
+    if "reject" in lower:
+        return STATUSES["rejected"], percent
+    if "proof" in lower:
+        return STATUSES["proofread"], percent
+    if "translate" in lower:
+        return STATUSES["translated"], percent
+
+    return DEFAULT_STATUS, percent
+
+
+def compose_memoq_status(
+    status_key: str,
+    match_percent: Optional[int] = None,
+    existing: Optional[str] = None,
+) -> str:
+    """Compose a memoQ status string, preserving existing text when provided."""
+    if existing and existing.strip():
+        return existing.strip()
+
+    status_def = get_status(status_key)
+    base = status_def.memoq_label
+    if match_percent is not None:
+        return f"{base} ({match_percent}%)"
+    return base
+
+

modules/style_guide_manager.py

@@ -0,0 +1,315 @@
+"""
+Style Guide Manager Module
+
+Manages translation style guides for different languages.
+Supports style guides as Markdown files with optional YAML frontmatter.
+
+Extracted for modularity and reusability.
+Supports both individual language-specific guides and optional user additions.
+"""
+
+import os
+import json
+import shutil
+import re
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple
+
+
+class StyleGuideLibrary:
+    """
+    Manages translation style guides for multiple languages.
+    Loads style guide files from appropriate folder based on dev mode.
+    """
+    
+    # Supported languages for style guides
+    SUPPORTED_LANGUAGES = [
+        "Dutch",
+        "English",
+        "Spanish",
+        "German",
+        "French"
+    ]
+    
+    def __init__(self, style_guides_dir=None, log_callback=None):
+        """
+        Initialize the Style Guide Library.
+        
+        Args:
+            style_guides_dir: Path to style guides directory (if None, must be set later)
+            log_callback: Function to call for logging messages
+        """
+        self.style_guides_dir = style_guides_dir
+        self.log = log_callback if log_callback else print
+        
+        # Create directory if it doesn't exist and path is provided
+        if self.style_guides_dir:
+            os.makedirs(self.style_guides_dir, exist_ok=True)
+        
+        # Available style guides: {language: guide_data}
+        self.guides = {}
+        self.active_guide = None  # Currently selected guide
+        self.active_guide_language = None
+    
+    def set_directory(self, style_guides_dir):
+        """Set the directory after initialization"""
+        self.style_guides_dir = style_guides_dir
+        os.makedirs(self.style_guides_dir, exist_ok=True)
+    
+    def load_all_guides(self):
+        """Load all style guides from the style guides directory"""
+        self.guides = {}
+        
+        if not self.style_guides_dir or not os.path.exists(self.style_guides_dir):
+            self.log("⚠ Style guides directory not found")
+            return 0
+        
+        count = self._load_from_directory(self.style_guides_dir)
+        self.log(f"✓ Loaded {count} style guides")
+        return count
+    
+    def _load_from_directory(self, directory):
+        """Load style guides from directory
+        
+        Expected file naming: <Language>.md or <Language>.txt
+        Examples: Dutch.md, English.md, Spanish.txt, etc.
+        
+        Args:
+            directory: Path to directory
+        """
+        count = 0
+        
+        if not directory or not os.path.exists(directory):
+            return count
+        
+        for filename in os.listdir(directory):
+            filepath = os.path.join(directory, filename)
+            
+            # Skip directories
+            if os.path.isdir(filepath):
+                continue
+            
+            # Check if file matches supported language format
+            if filename.endswith('.md') or filename.endswith('.txt'):
+                language = filename.rsplit('.', 1)[0]  # Remove extension
+                
+                # Load content
+                try:
+                    with open(filepath, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                    
+                    guide_data = {
+                        'language': language,
+                        'content': content,
+                        '_filename': filename,
+                        '_filepath': filepath,
+                        '_created': datetime.fromtimestamp(os.path.getctime(filepath)).isoformat(),
+                        '_modified': datetime.fromtimestamp(os.path.getmtime(filepath)).isoformat(),
+                    }
+                    
+                    self.guides[language] = guide_data
+                    count += 1
+                    
+                except Exception as e:
+                    self.log(f"⚠ Failed to load {filename}: {e}")
+        
+        return count
+    
+    def get_guide(self, language: str) -> Optional[Dict]:
+        """
+        Get a specific style guide by language.
+        
+        Args:
+            language: Language name (e.g., 'Dutch', 'English')
+        
+        Returns:
+            Dictionary with guide data or None if not found
+        """
+        return self.guides.get(language)
+    
+    def get_all_languages(self) -> List[str]:
+        """Get list of all available style guide languages"""
+        return sorted(self.guides.keys())
+    
+    def get_guide_content(self, language: str) -> Optional[str]:
+        """Get the content of a specific style guide"""
+        guide = self.guides.get(language)
+        return guide['content'] if guide else None
+    
+    def update_guide(self, language: str, new_content: str) -> bool:
+        """
+        Update a style guide with new content.
+        
+        Args:
+            language: Language name
+            new_content: New content for the guide
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        guide = self.guides.get(language)
+        if not guide:
+            self.log(f"⚠ Style guide not found: {language}")
+            return False
+        
+        try:
+            filepath = guide['_filepath']
+            
+            # Write to file
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(new_content)
+            
+            # Update in memory
+            guide['content'] = new_content
+            guide['_modified'] = datetime.now().isoformat()
+            
+            self.log(f"✓ Updated style guide: {language}")
+            return True
+        
+        except Exception as e:
+            self.log(f"⚠ Failed to update {language}: {e}")
+            return False
+    
+    def append_to_guide(self, language: str, additional_content: str) -> bool:
+        """
+        Append content to an existing style guide.
+        
+        Args:
+            language: Language name
+            additional_content: Content to append
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        guide = self.guides.get(language)
+        if not guide:
+            self.log(f"⚠ Style guide not found: {language}")
+            return False
+        
+        current_content = guide['content']
+        new_content = current_content.rstrip() + '\n\n' + additional_content.strip()
+        
+        return self.update_guide(language, new_content)
+    
+    def append_to_all_guides(self, additional_content: str) -> Tuple[int, int]:
+        """
+        Append content to all style guides.
+        
+        Args:
+            additional_content: Content to append to all guides
+        
+        Returns:
+            Tuple of (successful_count, failed_count)
+        """
+        successful = 0
+        failed = 0
+        
+        for language in self.guides.keys():
+            if self.append_to_guide(language, additional_content):
+                successful += 1
+            else:
+                failed += 1
+        
+        self.log(f"✓ Updated {successful} guides. Failed: {failed}")
+        return successful, failed
+    
+    def create_guide(self, language: str, content: str = "") -> bool:
+        """
+        Create a new style guide file.
+        
+        Args:
+            language: Language name
+            content: Initial content (optional)
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        if not self.style_guides_dir:
+            self.log("⚠ Style guides directory not set")
+            return False
+        
+        if language in self.guides:
+            self.log(f"⚠ Style guide already exists: {language}")
+            return False
+        
+        try:
+            filepath = os.path.join(self.style_guides_dir, f"{language}.md")
+            
+            # Create file
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(content)
+            
+            # Add to guides dictionary
+            guide_data = {
+                'language': language,
+                'content': content,
+                '_filename': f"{language}.md",
+                '_filepath': filepath,
+                '_created': datetime.now().isoformat(),
+                '_modified': datetime.now().isoformat(),
+            }
+            
+            self.guides[language] = guide_data
+            self.log(f"✓ Created style guide: {language}")
+            return True
+        
+        except Exception as e:
+            self.log(f"⚠ Failed to create {language}: {e}")
+            return False
+    
+    def export_guide(self, language: str, export_path: str) -> bool:
+        """
+        Export a style guide to a file.
+        
+        Args:
+            language: Language name
+            export_path: Path where to save the exported guide
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        guide = self.guides.get(language)
+        if not guide:
+            self.log(f"⚠ Style guide not found: {language}")
+            return False
+        
+        try:
+            with open(export_path, 'w', encoding='utf-8') as f:
+                f.write(guide['content'])
+            
+            self.log(f"✓ Exported style guide: {language}")
+            return True
+        
+        except Exception as e:
+            self.log(f"⚠ Failed to export {language}: {e}")
+            return False
+    
+    def import_guide(self, language: str, import_path: str, append: bool = False) -> bool:
+        """
+        Import a style guide from a file.
+        
+        Args:
+            language: Language name to import as
+            import_path: Path to the file to import
+            append: If True, append to existing guide; if False, replace
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            with open(import_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            if language not in self.guides:
+                # Create new guide
+                return self.create_guide(language, content)
+            elif append:
+                # Append to existing guide
+                return self.append_to_guide(language, content)
+            else:
+                # Replace existing guide
+                return self.update_guide(language, content)
+        
+        except Exception as e:
+            self.log(f"⚠ Failed to import from {import_path}: {e}")
+            return False