supervertaler 1.9.131__py3-none-any.whl → 1.9.173__py3-none-any.whl

modules/superbrowser.py

@@ -45,11 +45,12 @@ def _clear_corrupted_cache(storage_path: str):
 class ChatColumn(QWidget):
     """A column containing a chat interface with web browser"""
 
-    def __init__(self, title, url, header_color, parent=None):
+    def __init__(self, title, url, header_color, parent=None, user_data_path=None):
         super().__init__(parent)
         self.title = title
         self.url = url
         self.header_color = header_color
+        self.user_data_path = user_data_path  # Store user data path
         self.init_ui()
 
     def init_ui(self):
@@ -102,12 +103,14 @@ class ChatColumn(QWidget):
         profile_name = f"superbrowser_{self.title.lower()}"
         self.profile = QWebEngineProfile(profile_name, self)
         
-        # Set persistent storage path (use same pattern as main app)
-        # Check if running in dev mode (private data folder)
-        dev_mode_marker = os.path.join(os.path.dirname(__file__), "..", ".supervertaler.local")
-        base_folder = "user_data_private" if os.path.exists(dev_mode_marker) else "user_data"
-        
-        storage_path = os.path.join(os.path.dirname(__file__), "..", base_folder, "superbrowser_profiles", profile_name)
+        # Set persistent storage path using user_data_path from parent
+        if self.user_data_path:
+            storage_path = os.path.join(str(self.user_data_path), "superbrowser_profiles", profile_name)
+        else:
+            # Fallback to script directory if user_data_path not provided
+            dev_mode_marker = os.path.join(os.path.dirname(__file__), "..", ".supervertaler.local")
+            base_folder = "user_data_private" if os.path.exists(dev_mode_marker) else "user_data"
+            storage_path = os.path.join(os.path.dirname(__file__), "..", base_folder, "superbrowser_profiles", profile_name)
         os.makedirs(storage_path, exist_ok=True)
         
         # Clear potentially corrupted cache to prevent Chromium errors
@@ -166,9 +169,10 @@ class SuperbrowserWidget(QWidget):
     and concurrent interaction with different AI models.
     """
 
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, user_data_path=None):
         super().__init__(parent)
         self.parent_window = parent
+        self.user_data_path = user_data_path  # Store user data path for profiles
         
         # Default URLs for AI chat interfaces
         self.chatgpt_url = "https://chatgpt.com/"
@@ -257,10 +261,10 @@ class SuperbrowserWidget(QWidget):
         splitter = QSplitter(Qt.Orientation.Horizontal)
         splitter.setHandleWidth(3)
 
-        # Create chat columns
-        self.chatgpt_column = ChatColumn("ChatGPT", self.chatgpt_url, "#10a37f", self)
-        self.claude_column = ChatColumn("Claude", self.claude_url, "#c17c4f", self)
-        self.gemini_column = ChatColumn("Gemini", self.gemini_url, "#4285f4", self)
+        # Create chat columns - pass user_data_path for profile storage
+        self.chatgpt_column = ChatColumn("ChatGPT", self.chatgpt_url, "#10a37f", self, user_data_path=self.user_data_path)
+        self.claude_column = ChatColumn("Claude", self.claude_url, "#c17c4f", self, user_data_path=self.user_data_path)
+        self.gemini_column = ChatColumn("Gemini", self.gemini_url, "#4285f4", self, user_data_path=self.user_data_path)
 
         # Add columns to splitter
         splitter.addWidget(self.chatgpt_column)

modules/superlookup.py

@@ -88,14 +88,18 @@ class SuperlookupEngine:
             Captured text or None if failed
         """
         try:
-            import keyboard
-            
-            # Wait for hotkey to release before sending Ctrl+C
-            time.sleep(0.2)
-            
-            # Use keyboard library to send Ctrl+C
-            keyboard.press_and_release('ctrl+c')
-            time.sleep(0.2)
+            # keyboard module is Windows-only
+            try:
+                import keyboard
+                # Wait for hotkey to release before sending Ctrl+C
+                time.sleep(0.2)
+                # Use keyboard library to send Ctrl+C
+                keyboard.press_and_release('ctrl+c')
+                time.sleep(0.2)
+            except ImportError:
+                # On non-Windows, just try to get clipboard content directly
+                # (user needs to have copied text manually)
+                pass
             
             # Get clipboard
             text = pyperclip.paste()
@@ -157,9 +161,13 @@ class SuperlookupEngine:
                 
                 # Convert to LookupResult format (limit results)
                 for match in matches[:max_results]:
+                    # Use 'source' and 'target' keys (matches database column names)
+                    source_text = match.get('source', '')
+                    target_text = match.get('target', '')
+                    print(f"[Superlookup] Extracted: source='{source_text[:50]}...', target='{target_text[:50]}...'")
                     results.append(LookupResult(
-                        source=match.get('source', ''),
-                        target=match.get('target', ''),
+                        source=source_text,
+                        target=target_text,
                         match_percent=100,  # Concordance = contains the text
                         source_type='tm',
                         metadata={

modules/tag_manager.py

@@ -77,15 +77,33 @@ class TagManager:
         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=run.bold or False,
-                italic=run.italic or False,
+                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,

modules/termview_widget.py

@@ -515,6 +515,9 @@ class TermviewWidget(QWidget):
         self.current_target_lang = None
         self.current_project_id = None  # Store project ID for termbase priority lookup
         
+        # Debug mode - disable verbose tokenization logging by default (performance)
+        self.debug_tokenize = False
+        
         # Default font settings (will be updated from main app settings)
         self.current_font_family = "Segoe UI"
         self.current_font_size = 10
@@ -750,7 +753,10 @@ class TermviewWidget(QWidget):
                 if not source_term or not target_term:
                     continue
                 
-                key = source_term.lower()
+                # Strip punctuation from key to match lookup normalization
+                # This ensures "ca." in glossary matches "ca." token stripped to "ca"
+                PUNCT_CHARS_FOR_KEY = '.,;:!?\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A()[]'
+                key = source_term.lower().strip(PUNCT_CHARS_FOR_KEY)
                 if key not in matches_dict:
                     matches_dict[key] = []
                 
@@ -803,7 +809,8 @@ class TermviewWidget(QWidget):
         
         # Comprehensive set of quote and punctuation characters to strip
         # Using Unicode escapes to avoid encoding issues
-        PUNCT_CHARS = '.,;:!?\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A'
+        # Include brackets for terms like "(typisch)" to match "typisch"
+        PUNCT_CHARS = '.,;:!?\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A()[]'
         
         # Track which terms have already been assigned shortcuts (avoid duplicates)
         assigned_shortcuts = set()
@@ -816,7 +823,6 @@ class TermviewWidget(QWidget):
             
             # Check if this is a non-translatable
             if lookup_key in nt_dict:
-                # Create NT block
                 nt_block = NTBlock(token, nt_dict[lookup_key], self, theme_manager=self.theme_manager, 
                                    font_size=self.current_font_size, font_family=self.current_font_family, 
                                    font_bold=self.current_font_bold)
@@ -992,9 +998,9 @@ class TermviewWidget(QWidget):
         Returns:
             List of tokens (words/phrases/numbers), with multi-word terms kept together
         """
-        # DEBUG: Log multi-word terms we're looking for
+        # DEBUG: Log multi-word terms we're looking for (only if debug_tokenize enabled)
         multi_word_terms = [k for k in matches.keys() if ' ' in k]
-        if multi_word_terms:
+        if multi_word_terms and self.debug_tokenize:
             self.log(f"🔍 Tokenize: Looking for {len(multi_word_terms)} multi-word terms:")
             for term in sorted(multi_word_terms, key=len, reverse=True)[:3]:
                 self.log(f"    - '{term}'")
@@ -1019,11 +1025,12 @@ class TermviewWidget(QWidget):
                 else:
                     pattern = r'\b' + term_escaped + r'\b'
                 
-                # DEBUG: Check if multi-word term is found
+                # DEBUG: Check if multi-word term is found (only if debug_tokenize enabled)
                 found = re.search(pattern, text_lower)
-                self.log(f"🔍 Tokenize: Pattern '{pattern}' for '{term}' → {'FOUND' if found else 'NOT FOUND'}")
-                if found:
-                    self.log(f"    Match at position {found.span()}: '{text[found.start():found.end()]}'")
+                if self.debug_tokenize:
+                    self.log(f"🔍 Tokenize: Pattern '{pattern}' for '{term}' → {'FOUND' if found else 'NOT FOUND'}")
+                    if found:
+                        self.log(f"    Match at position {found.span()}: '{text[found.start():found.end()]}'")
                 
                 # Find all matches using regex
                 for match in re.finditer(pattern, text_lower):
@@ -1036,10 +1043,11 @@ class TermviewWidget(QWidget):
                         original_term = text[pos:pos + len(term)]
                         tokens_with_positions.append((pos, len(term), original_term))
                         used_positions.update(term_positions)
-                        self.log(f"    ✅ Added multi-word token: '{original_term}' covering positions {pos}-{pos+len(term)}")
+                        if self.debug_tokenize:
+                            self.log(f"    ✅ Added multi-word token: '{original_term}' covering positions {pos}-{pos+len(term)}")
         
-        # DEBUG: Log used_positions after first pass
-        if ' ' in sorted(matches.keys(), key=len, reverse=True)[0]:
+        # DEBUG: Log used_positions after first pass (only if debug_tokenize enabled)
+        if matches and ' ' in sorted(matches.keys(), key=len, reverse=True)[0] and self.debug_tokenize:
             self.log(f"🔍 After first pass: {len(used_positions)} positions marked as used")
             self.log(f"    Used positions: {sorted(list(used_positions))[:20]}...")
         

modules/tm_metadata_manager.py

@@ -396,6 +396,47 @@ class TMMetadataManager:
             self.log(f"✗ Error fetching active tm_ids: {e}")
             return []
     
+    def get_writable_tm_ids(self, project_id: Optional[int]) -> List[str]:
+        """
+        Get list of writable tm_id strings for a project.
+        
+        Returns TMs where:
+        - The TM has an activation record for this project AND
+        - read_only = 0 (Write checkbox is enabled)
+        
+        This is used for SAVING segments to TM, separate from get_active_tm_ids()
+        which is used for READING/matching from TM.
+        
+        Returns:
+            List of tm_id strings that are writable for the project
+        """
+        if project_id is None:
+            # No project - return all writable TMs
+            try:
+                cursor = self.db_manager.cursor
+                cursor.execute("SELECT tm_id FROM translation_memories WHERE read_only = 0")
+                return [row[0] for row in cursor.fetchall()]
+            except Exception as e:
+                self.log(f"✗ Error fetching all writable tm_ids: {e}")
+                return []
+        
+        try:
+            cursor = self.db_manager.cursor
+            
+            # Return TMs where Write checkbox is enabled (read_only = 0)
+            # AND the TM has an activation record for this project
+            cursor.execute("""
+                SELECT tm.tm_id 
+                FROM translation_memories tm
+                INNER JOIN tm_activation ta ON tm.id = ta.tm_id
+                WHERE ta.project_id = ? AND tm.read_only = 0
+            """, (project_id,))
+            
+            return [row[0] for row in cursor.fetchall()]
+        except Exception as e:
+            self.log(f"✗ Error fetching writable tm_ids: {e}")
+            return []
+    
     # ========================================================================
     # PROJECT TM MANAGEMENT (similar to termbases)
     # ========================================================================

modules/tmx_editor_qt.py

@@ -2655,7 +2655,7 @@ if __name__ == "__main__":
         os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".supervertaler.local")
     )
     user_data_path = Path("user_data_private" if ENABLE_PRIVATE_FEATURES else "user_data")
-    db_path = user_data_path / "Translation_Resources" / "supervertaler.db"
+    db_path = user_data_path / "resources" / "supervertaler.db"
     
     # Ensure database directory exists
     db_path.parent.mkdir(parents=True, exist_ok=True)

modules/translation_memory.py

@@ -123,7 +123,7 @@ class TMDatabase:
         if source_lang and target_lang:
             self.set_tm_languages(source_lang, target_lang)
         
-        # Global fuzzy threshold
+        # Global fuzzy threshold (75% minimum similarity for fuzzy matches)
         self.fuzzy_threshold = 0.75
         
         # TM metadata cache (populated from database as needed)
@@ -401,7 +401,7 @@ class TMDatabase:
     
     def load_tmx_file(self, filepath: str, src_lang: str, tgt_lang: str, 
                       tm_name: str = None, read_only: bool = False, 
-                      strip_variants: bool = True) -> tuple[str, int]:
+                      strip_variants: bool = True, progress_callback=None) -> tuple[str, int]:
         """
         Load TMX file into a new custom TM
         
@@ -412,6 +412,7 @@ class TMDatabase:
             tm_name: Custom name for TM (default: filename)
             read_only: Make TM read-only
             strip_variants: Match base languages ignoring regional variants (default: True)
+            progress_callback: Optional callback function(current, total, message) for progress updates
         
         Returns: (tm_id, entry_count)
         """
@@ -423,16 +424,18 @@ class TMDatabase:
         self.add_custom_tm(tm_name, tm_id, read_only=read_only)
         
         # Load TMX content
-        loaded_count = self._load_tmx_into_db(filepath, src_lang, tgt_lang, tm_id, strip_variants=strip_variants)
+        loaded_count = self._load_tmx_into_db(filepath, src_lang, tgt_lang, tm_id, 
+                                             strip_variants=strip_variants, 
+                                             progress_callback=progress_callback)
         
         self.log(f"✓ Loaded {loaded_count} entries from {os.path.basename(filepath)}")
         
         return tm_id, loaded_count
     
     def _load_tmx_into_db(self, filepath: str, src_lang: str, tgt_lang: str, tm_id: str, 
-                          strip_variants: bool = False) -> int:
+                          strip_variants: bool = False, progress_callback=None) -> int:
         """
-        Internal: Load TMX content into database
+        Internal: Load TMX content into database with chunked processing
         
         Args:
             filepath: Path to TMX file
@@ -440,12 +443,24 @@ class TMDatabase:
             tgt_lang: Target target language code  
             tm_id: TM identifier
             strip_variants: If True, match base languages ignoring regional variants
+            progress_callback: Optional callback function(current, total, message) for progress updates
         """
         loaded_count = 0
+        chunk_size = 1000  # Process in chunks for responsiveness
+        chunk_buffer = []
         
         try:
+            # First pass: count total TUs for progress bar
+            if progress_callback:
+                progress_callback(0, 0, "Counting translation units...")
+            
             tree = ET.parse(filepath)
             root = tree.getroot()
+            total_tus = len(root.findall('.//tu'))
+            
+            if progress_callback:
+                progress_callback(0, total_tus, f"Processing 0 / {total_tus:,} entries...")
+            
             xml_ns = "http://www.w3.org/XML/1998/namespace"
             
             # Normalize language codes
@@ -458,6 +473,7 @@ class TMDatabase:
                 src_base = get_base_lang_code(src_lang_normalized)
                 tgt_base = get_base_lang_code(tgt_lang_normalized)
             
+            processed = 0
             for tu in root.findall('.//tu'):
                 src_text, tgt_text = None, None
                 
@@ -488,14 +504,43 @@ class TMDatabase:
                                 tgt_text = text
                 
                 if src_text and tgt_text:
+                    chunk_buffer.append((src_text, tgt_text))
+                    loaded_count += 1
+                    
+                    # Process chunk when buffer is full
+                    if len(chunk_buffer) >= chunk_size:
+                        for src, tgt in chunk_buffer:
+                            self.db.add_translation_unit(
+                                source=src,
+                                target=tgt,
+                                source_lang=src_lang_normalized,
+                                target_lang=tgt_lang_normalized,
+                                tm_id=tm_id
+                            )
+                        chunk_buffer.clear()
+                        
+                        # Update progress
+                        if progress_callback:
+                            progress_callback(processed + 1, total_tus, 
+                                            f"Processing {loaded_count:,} / {total_tus:,} entries...")
+                
+                processed += 1
+            
+            # Process remaining entries in buffer
+            if chunk_buffer:
+                for src, tgt in chunk_buffer:
                     self.db.add_translation_unit(
-                        source=src_text,
-                        target=tgt_text,
+                        source=src,
+                        target=tgt,
                         source_lang=src_lang_normalized,
                         target_lang=tgt_lang_normalized,
                         tm_id=tm_id
                     )
-                    loaded_count += 1
+                chunk_buffer.clear()
+            
+            # Final progress update
+            if progress_callback:
+                progress_callback(total_tus, total_tus, f"Completed: {loaded_count:,} entries imported")
             
             return loaded_count
         except Exception as e:

modules/unified_prompt_library.py

@@ -30,7 +30,7 @@ class UnifiedPromptLibrary:
         Initialize the Unified Prompt Library.
         
         Args:
-            library_dir: Path to unified library directory (user_data/Prompt_Library/Library)
+            library_dir: Path to unified library directory (user_data/prompt_library)
             log_callback: Function to call for logging messages
         """
         self.library_dir = Path(library_dir) if library_dir else None

modules/unified_prompt_manager_qt.py

@@ -544,8 +544,8 @@ class UnifiedPromptManagerQt:
         self.log = parent_app.log if hasattr(parent_app, 'log') else print
         
         # Paths
-        self.prompt_library_dir = self.user_data_path / "Prompt_Library"
-        # Use Prompt_Library directly, not Prompt_Library/Library
+        self.prompt_library_dir = self.user_data_path / "prompt_library"
+        # Use prompt_library directly, not prompt_library/Library
         self.unified_library_dir = self.prompt_library_dir
 
         # Run migration if needed
@@ -579,7 +579,7 @@ class UnifiedPromptManagerQt:
         self._cached_document_markdown: Optional[str] = None  # Cached markdown conversion of current document
 
         # Initialize Attachment Manager
-        ai_assistant_dir = self.user_data_path / "AI_Assistant"
+        ai_assistant_dir = self.user_data_path / "ai_assistant"
         self.attachment_manager = AttachmentManager(
             base_dir=str(ai_assistant_dir),
             log_callback=self.log_message
@@ -694,7 +694,7 @@ class UnifiedPromptManagerQt:
         layout.setSpacing(5)
         
         # Title
-        title = QLabel("🤖 Prompt Manager")
+        title = QLabel("📝 Prompt Manager")
         title.setStyleSheet("font-size: 16pt; font-weight: bold; color: #1976D2;")
         layout.addWidget(title, 0)
         
@@ -1546,7 +1546,7 @@ class UnifiedPromptManagerQt:
     
     def _create_active_config_panel(self) -> QGroupBox:
         """Create active prompt configuration panel"""
-        group = QGroupBox("Active Configuration")
+        group = QGroupBox("Active Prompt")
         layout = QVBoxLayout()
         
         # Mode info (read-only, auto-selected)
@@ -1704,10 +1704,10 @@ class UnifiedPromptManagerQt:
         self.editor_quickmenu_label_input.setPlaceholderText("Label shown in QuickMenu")
         quickmenu_layout.addWidget(self.editor_quickmenu_label_input, 2)
 
-        self.editor_quickmenu_in_grid_cb = CheckmarkCheckBox("Show in Grid right-click QuickMenu")
+        self.editor_quickmenu_in_grid_cb = CheckmarkCheckBox("Show in QuickMenu (in-app)")
         quickmenu_layout.addWidget(self.editor_quickmenu_in_grid_cb, 2)
 
-        self.editor_quickmenu_in_quickmenu_cb = CheckmarkCheckBox("Show in Supervertaler QuickMenu")
+        self.editor_quickmenu_in_quickmenu_cb = CheckmarkCheckBox("Show in QuickMenu (global)")
         quickmenu_layout.addWidget(self.editor_quickmenu_in_quickmenu_cb, 1)
 
         layout.addLayout(quickmenu_layout)
@@ -1760,26 +1760,7 @@ class UnifiedPromptManagerQt:
             item.setFlags(item.flags() | Qt.ItemFlag.ItemIsDragEnabled)
             favorites_root.addChild(item)
         
-        # QuickMenu section (legacy kind name: quick_run)
-        quick_run_root = QTreeWidgetItem(["⚡ QuickMenu"])
-        # Special node: not draggable/droppable
-        quick_run_root.setData(0, Qt.ItemDataRole.UserRole, {'type': 'special', 'kind': 'quick_run'})
-        quick_run_root.setExpanded(False)
-        font = quick_run_root.font(0)
-        font.setBold(True)
-        quick_run_root.setFont(0, font)
-        self.tree_widget.addTopLevelItem(quick_run_root)
-        
-        quickmenu_items = self.library.get_quickmenu_prompts() if hasattr(self.library, 'get_quickmenu_prompts') else self.library.get_quick_run_prompts()
-        self.log_message(f"🔍 DEBUG: QuickMenu count: {len(quickmenu_items)}")
-        for path, label in quickmenu_items:
-            item = QTreeWidgetItem([label])
-            item.setData(0, Qt.ItemDataRole.UserRole, {'type': 'prompt', 'path': path})
-            # Quick Run entries are shortcuts, but allow dragging to move the actual prompt file.
-            item.setFlags(item.flags() | Qt.ItemFlag.ItemIsDragEnabled)
-            quick_run_root.addChild(item)
-        
-        # Library folders
+        # Library folders (QuickMenu parent folder removed - folder hierarchy now defines menu structure)
         self.log_message(f"🔍 DEBUG: Building tree from {self.unified_library_dir}")
         self._build_tree_recursive(None, self.unified_library_dir, "")
         
@@ -3548,7 +3529,7 @@ Output complete ACTION."""
         """
         Save the markdown conversion of the current document.
 
-        Saves to: user_data_private/AI_Assistant/current_document/
+        Saves to: user_data_private/ai_assistant/current_document/
 
         Args:
             original_path: Original document file path
@@ -3556,7 +3537,7 @@ Output complete ACTION."""
         """
         try:
             # Create directory for current document markdown
-            doc_dir = self.user_data_path / "AI_Assistant" / "current_document"
+            doc_dir = self.user_data_path / "ai_assistant" / "current_document"
             doc_dir.mkdir(parents=True, exist_ok=True)
 
             # Create filename based on original