supervertaler 1.9.176b0__py3-none-any.whl → 1.9.178__py3-none-any.whl

Supervertaler.py

@@ -3,8 +3,6 @@ Supervertaler
 =============
 The Ultimate Translation Workbench.
 Modern PyQt6 interface with specialised modules to handle any problem.
-Version: 1.9.153 (Tab Layout Reorganization)
-Release Date: January 23, 2026
 Framework: PyQt6
 
 This is the modern edition of Supervertaler using PyQt6 framework.
@@ -34,7 +32,7 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.176-beta"
+__version__ = "1.9.178"
 __phase__ = "0.9"
 __release_date__ = "2026-01-28"
 __edition__ = "Qt"
@@ -10622,7 +10620,11 @@ class SupervertalerQt(QMainWindow):
         button_layout = QHBoxLayout()
         
         create_btn = QPushButton("+ Create New TM")
-        create_btn.clicked.connect(lambda: self._show_create_tm_dialog(tm_metadata_mgr, refresh_tm_list, project_id))
+        # Get project_id dynamically - use 0 (global) when no project is loaded
+        create_btn.clicked.connect(lambda: self._show_create_tm_dialog(
+            tm_metadata_mgr, refresh_tm_list,
+            self.current_project.id if (hasattr(self, 'current_project') and self.current_project and hasattr(self.current_project, 'id')) else 0
+        ))
         button_layout.addWidget(create_btn)
         
         import_btn = QPushButton("📥 Import TMX")
@@ -14974,8 +14976,8 @@ class SupervertalerQt(QMainWindow):
             )
             
             if result:
-                # Auto-activate for current project
-                if project_id:
+                # Auto-activate for current project (or global=0 if no project loaded)
+                if project_id is not None:
                     tm_metadata_mgr.activate_tm(result, project_id)
                 
                 QMessageBox.information(self, "Success", f"Translation Memory '{name}' created successfully!")
@@ -22319,20 +22321,24 @@ class SupervertalerQt(QMainWindow):
         """
         Search termbases using a provided cursor (thread-safe for background threads).
         This method allows background workers to query the database without SQLite threading errors.
-        
+
+        Implements BIDIRECTIONAL matching: searches both source_term and target_term columns.
+        When a match is found on target_term, source and target are swapped in the result.
+        This matches memoQ/Trados behavior where a NL→EN termbase also works for EN→NL projects.
+
         Args:
             source_text: The source text to search for
             cursor: A database cursor from a thread-local connection
             source_lang: Source language code
             target_lang: Target language code
             project_id: Current project ID (required to filter by activated termbases)
-        
+
         Returns:
             Dictionary of {term: translation} matches
         """
         if not source_text or not cursor:
             return {}
-        
+
         try:
             # Convert language names to codes (match interactive search logic)
             source_lang_code = self._convert_language_to_code(source_lang) if source_lang else None
@@ -22352,20 +22358,26 @@ class SupervertalerQt(QMainWindow):
                 try:
                     # JOIN termbases AND termbase_activation to filter by activated termbases
                     # This matches the logic in database_manager.py search_termbases()
+                    # BIDIRECTIONAL: Search both source_term (forward) and target_term (reverse)
+                    # Using UNION to combine both directions
                     query = """
-                        SELECT 
-                            t.id, t.source_term, t.target_term, t.termbase_id, t.priority,
-                            t.domain, t.notes, t.project, t.client, t.forbidden,
-                            tb.is_project_termbase, tb.name as termbase_name, 
-                            COALESCE(ta.priority, tb.ranking) as ranking
-                        FROM termbase_terms t
-                        LEFT JOIN termbases tb ON CAST(t.termbase_id AS INTEGER) = tb.id
-                        LEFT JOIN termbase_activation ta ON ta.termbase_id = tb.id AND ta.project_id = ? AND ta.is_active = 1
-                        WHERE LOWER(t.source_term) LIKE ?
-                        AND (ta.is_active = 1 OR tb.is_project_termbase = 1)
+                        SELECT * FROM (
+                            -- Forward match: search source_term
+                            SELECT
+                                t.id, t.source_term, t.target_term, t.termbase_id, t.priority,
+                                t.domain, t.notes, t.project, t.client, t.forbidden,
+                                tb.is_project_termbase, tb.name as termbase_name,
+                                COALESCE(ta.priority, tb.ranking) as ranking,
+                                'source' as match_direction
+                            FROM termbase_terms t
+                            LEFT JOIN termbases tb ON CAST(t.termbase_id AS INTEGER) = tb.id
+                            LEFT JOIN termbase_activation ta ON ta.termbase_id = tb.id AND ta.project_id = ? AND ta.is_active = 1
+                            WHERE LOWER(t.source_term) LIKE ?
+                            AND (ta.is_active = 1 OR tb.is_project_termbase = 1)
                     """
                     params = [project_id if project_id else 0, f"%{clean_word.lower()}%"]
 
+                    # Language filters for forward query
                     if source_lang_code:
                         query += " AND (t.source_lang = ? OR (t.source_lang IS NULL AND tb.source_lang = ?) OR (t.source_lang IS NULL AND tb.source_lang IS NULL))"
                         params.extend([source_lang_code, source_lang_code])
@@ -22373,15 +22385,45 @@ class SupervertalerQt(QMainWindow):
                         query += " AND (t.target_lang = ? OR (t.target_lang IS NULL AND tb.target_lang = ?) OR (t.target_lang IS NULL AND tb.target_lang IS NULL))"
                         params.extend([target_lang_code, target_lang_code])
 
-                    # Limit raw hits per word to keep batch worker light
-                    query += " LIMIT 15"
+                    # Reverse match: search target_term, swap source/target in output
+                    query += """
+                            UNION ALL
+                            -- Reverse match: search target_term, swap columns
+                            SELECT
+                                t.id, t.target_term as source_term, t.source_term as target_term,
+                                t.termbase_id, t.priority,
+                                t.domain, t.notes, t.project, t.client, t.forbidden,
+                                tb.is_project_termbase, tb.name as termbase_name,
+                                COALESCE(ta.priority, tb.ranking) as ranking,
+                                'target' as match_direction
+                            FROM termbase_terms t
+                            LEFT JOIN termbases tb ON CAST(t.termbase_id AS INTEGER) = tb.id
+                            LEFT JOIN termbase_activation ta ON ta.termbase_id = tb.id AND ta.project_id = ? AND ta.is_active = 1
+                            WHERE LOWER(t.target_term) LIKE ?
+                            AND (ta.is_active = 1 OR tb.is_project_termbase = 1)
+                    """
+                    params.extend([project_id if project_id else 0, f"%{clean_word.lower()}%"])
+
+                    # Language filters for reverse query (swapped)
+                    if source_lang_code:
+                        # For reverse: source_lang filters target_lang column
+                        query += " AND (t.target_lang = ? OR (t.target_lang IS NULL AND tb.target_lang = ?) OR (t.target_lang IS NULL AND tb.target_lang IS NULL))"
+                        params.extend([source_lang_code, source_lang_code])
+                    if target_lang_code:
+                        # For reverse: target_lang filters source_lang column
+                        query += " AND (t.source_lang = ? OR (t.source_lang IS NULL AND tb.source_lang = ?) OR (t.source_lang IS NULL AND tb.source_lang IS NULL))"
+                        params.extend([target_lang_code, target_lang_code])
+
+                    # Close UNION and limit
+                    query += ") combined LIMIT 30"
                     cursor.execute(query, params)
                     results = cursor.fetchall()
 
                     for row in results:
-                        # Uniform access
+                        # Uniform access (columns are already swapped for reverse matches)
                         source_term = row[1] if isinstance(row, tuple) else row['source_term']
                         target_term = row[2] if isinstance(row, tuple) else row['target_term']
+                        match_direction = row[13] if isinstance(row, tuple) else row.get('match_direction', 'source')
                         if not source_term or not target_term:
                             continue
 
@@ -22405,8 +22447,10 @@ class SupervertalerQt(QMainWindow):
                         existing = matches.get(source_term.strip())
                         # Deduplicate: keep numerically lowest ranking (highest priority)
                         # For project termbases, ranking is None so they always win
+                        # Also prefer 'source' matches over 'target' matches when equal
                         if existing:
                             existing_ranking = existing.get('ranking', None)
+                            existing_direction = existing.get('match_direction', 'source')
                             if is_project_tb:
                                 # Project termbase always wins
                                 pass
@@ -22415,8 +22459,12 @@ class SupervertalerQt(QMainWindow):
                                 continue
                             elif existing_ranking is not None and ranking is not None:
                                 # Both have rankings, keep lower (higher priority)
-                                if existing_ranking <= ranking:
+                                if existing_ranking < ranking:
                                     continue
+                                elif existing_ranking == ranking:
+                                    # Same ranking: prefer source match over target match
+                                    if existing_direction == 'source' and match_direction == 'target':
+                                        continue
 
                         matches[source_term.strip()] = {
                             'translation': target_term.strip(),
@@ -22431,15 +22479,18 @@ class SupervertalerQt(QMainWindow):
                             'forbidden': forbidden or False,
                             'is_project_termbase': bool(is_project_tb),
                             'termbase_name': termbase_name or '',
-                            'target_synonyms': []  # Will be populated below
+                            'target_synonyms': [],  # Will be populated below
+                            'match_direction': match_direction  # Track if this was a reverse match
                         }
-                        
+
                         # Fetch synonyms for this term
+                        # For reverse matches, fetch 'source' synonyms since they become targets
                         try:
+                            synonym_lang = 'source' if match_direction == 'target' else 'target'
                             cursor.execute("""
-                                SELECT synonym_text FROM termbase_synonyms 
-                                WHERE term_id = ? AND language = 'target' AND forbidden = 0
-                            """, (term_id,))
+                                SELECT synonym_text FROM termbase_synonyms
+                                WHERE term_id = ? AND language = ? AND forbidden = 0
+                            """, (term_id, synonym_lang))
                             synonym_rows = cursor.fetchall()
                             for syn_row in synonym_rows:
                                 synonym = syn_row[0] if isinstance(syn_row, tuple) else syn_row['synonym_text']
@@ -26645,24 +26696,32 @@ class SupervertalerQt(QMainWindow):
                 )
                 return
             
-            # Extract segments
-            mqxliff_segments = handler.extract_source_segments()
-            
+            # Extract segments (including targets for pretranslated files)
+            mqxliff_segments = handler.extract_bilingual_segments()
+
             if not mqxliff_segments:
                 QMessageBox.warning(
                     self, "No Segments",
                     "No segments found in the memoQ XLIFF file."
                 )
                 return
-            
+
+            # Count pretranslated segments
+            pretranslated_count = sum(1 for s in mqxliff_segments if s.get('target', '').strip())
+
             # Convert to internal Segment format
             segments = []
             for i, mq_seg in enumerate(mqxliff_segments):
+                # Map status from mqxliff
+                status = mq_seg.get('status', 'not_started')
+                if status not in ['not_started', 'pre_translated', 'translated', 'confirmed', 'locked']:
+                    status = 'not_started'
+
                 segment = Segment(
                     id=i + 1,
-                    source=mq_seg.plain_text,
-                    target="",
-                    status=DEFAULT_STATUS.key,
+                    source=mq_seg.get('source', ''),
+                    target=mq_seg.get('target', ''),
+                    status=status,
                     notes="",
                 )
                 segments.append(segment)
@@ -26706,11 +26765,17 @@ class SupervertalerQt(QMainWindow):
             # Log success
             self.log(f"✓ Imported {len(segments)} segments from memoQ XLIFF: {Path(file_path).name}")
             self.log(f"  Source: {source_lang}, Target: {target_lang}")
-            
+            if pretranslated_count > 0:
+                self.log(f"  Pretranslated: {pretranslated_count} segments with target text")
+
+            # Build message with pretranslation info
+            msg = f"Successfully imported {len(segments)} segment(s) from memoQ XLIFF.\n\nLanguages: {source_lang} → {target_lang}"
+            if pretranslated_count > 0:
+                msg += f"\n\nPretranslated: {pretranslated_count} segment(s) with target text loaded."
+
             QMessageBox.information(
                 self, "Import Successful",
-                f"Successfully imported {len(segments)} segment(s) from memoQ XLIFF.\n\n"
-                f"Languages: {source_lang} → {target_lang}"
+                msg
             )
         except Exception as e:
             self.log(f"❌ Error importing memoQ XLIFF: {e}")
@@ -27119,7 +27184,19 @@ class SupervertalerQt(QMainWindow):
             source_row = QHBoxLayout()
             source_row.addWidget(QLabel("Source Language:"))
             source_combo = QComboBox()
-            source_combo.addItems(["English", "Dutch", "German", "French", "Spanish", "Italian", "Portuguese", "Polish", "Chinese", "Japanese", "Korean", "Russian"])
+            # Full language list (same as New Project dialog)
+            available_languages = [
+                "Afrikaans", "Albanian", "Arabic", "Armenian", "Basque", "Bengali",
+                "Bulgarian", "Catalan", "Chinese (Simplified)", "Chinese (Traditional)",
+                "Croatian", "Czech", "Danish", "Dutch", "English", "Estonian",
+                "Finnish", "French", "Galician", "Georgian", "German", "Greek",
+                "Hebrew", "Hindi", "Hungarian", "Icelandic", "Indonesian", "Irish",
+                "Italian", "Japanese", "Korean", "Latvian", "Lithuanian", "Macedonian",
+                "Malay", "Norwegian", "Persian", "Polish", "Portuguese", "Romanian",
+                "Russian", "Serbian", "Slovak", "Slovenian", "Spanish", "Swahili",
+                "Swedish", "Thai", "Turkish", "Ukrainian", "Urdu", "Vietnamese", "Welsh"
+            ]
+            source_combo.addItems(available_languages)
             # Try to match current UI selection
             current_source = self.source_lang_combo.currentText() if hasattr(self, 'source_lang_combo') else "English"
             source_idx = source_combo.findText(current_source)
@@ -27127,12 +27204,12 @@ class SupervertalerQt(QMainWindow):
                 source_combo.setCurrentIndex(source_idx)
             source_row.addWidget(source_combo)
             lang_group_layout.addLayout(source_row)
-            
+
             # Target language
             target_row = QHBoxLayout()
             target_row.addWidget(QLabel("Target Language:"))
             target_combo = QComboBox()
-            target_combo.addItems(["English", "Dutch", "German", "French", "Spanish", "Italian", "Portuguese", "Polish", "Chinese", "Japanese", "Korean", "Russian"])
+            target_combo.addItems(available_languages)
             # Try to match current UI selection
             current_target = self.target_lang_combo.currentText() if hasattr(self, 'target_lang_combo') else "Dutch"
             target_idx = target_combo.findText(current_target)
@@ -27140,15 +27217,15 @@ class SupervertalerQt(QMainWindow):
                 target_combo.setCurrentIndex(target_idx)
             target_row.addWidget(target_combo)
             lang_group_layout.addLayout(target_row)
-            
+
             lang_layout.addWidget(lang_group)
-            
+
             # Buttons
             lang_buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
             lang_buttons.accepted.connect(lang_dialog.accept)
             lang_buttons.rejected.connect(lang_dialog.reject)
             lang_layout.addWidget(lang_buttons)
-            
+
             if lang_dialog.exec() != QDialog.DialogCode.Accepted:
                 self.log("✗ User cancelled Trados import during language selection")
                 return
@@ -27799,7 +27876,19 @@ class SupervertalerQt(QMainWindow):
             source_row = QHBoxLayout()
             source_row.addWidget(QLabel("Source Language:"))
             source_combo = QComboBox()
-            source_combo.addItems(["English", "Dutch", "German", "French", "Spanish", "Italian", "Portuguese", "Polish", "Chinese", "Japanese", "Korean", "Russian"])
+            # Full language list (same as New Project dialog)
+            available_languages = [
+                "Afrikaans", "Albanian", "Arabic", "Armenian", "Basque", "Bengali",
+                "Bulgarian", "Catalan", "Chinese (Simplified)", "Chinese (Traditional)",
+                "Croatian", "Czech", "Danish", "Dutch", "English", "Estonian",
+                "Finnish", "French", "Galician", "Georgian", "German", "Greek",
+                "Hebrew", "Hindi", "Hungarian", "Icelandic", "Indonesian", "Irish",
+                "Italian", "Japanese", "Korean", "Latvian", "Lithuanian", "Macedonian",
+                "Malay", "Norwegian", "Persian", "Polish", "Portuguese", "Romanian",
+                "Russian", "Serbian", "Slovak", "Slovenian", "Spanish", "Swahili",
+                "Swedish", "Thai", "Turkish", "Ukrainian", "Urdu", "Vietnamese", "Welsh"
+            ]
+            source_combo.addItems(available_languages)
             # Try to match current UI selection
             current_source = self.source_lang_combo.currentText() if hasattr(self, 'source_lang_combo') else "English"
             source_idx = source_combo.findText(current_source)
@@ -27812,7 +27901,7 @@ class SupervertalerQt(QMainWindow):
             target_row = QHBoxLayout()
             target_row.addWidget(QLabel("Target Language:"))
             target_combo = QComboBox()
-            target_combo.addItems(["English", "Dutch", "German", "French", "Spanish", "Italian", "Portuguese", "Polish", "Chinese", "Japanese", "Korean", "Russian"])
+            target_combo.addItems(available_languages)
             # Try to match current UI selection
             current_target = self.target_lang_combo.currentText() if hasattr(self, 'target_lang_combo') else "Dutch"
             target_idx = target_combo.findText(current_target)

modules/database_manager.py

@@ -1477,120 +1477,225 @@ class DatabaseManager:
         # TODO: Implement in Phase 3
         pass
     
-    def search_termbases(self, search_term: str, source_lang: str = None, 
+    def search_termbases(self, search_term: str, source_lang: str = None,
                         target_lang: str = None, project_id: str = None,
-                        min_length: int = 0) -> List[Dict]:
+                        min_length: int = 0, bidirectional: bool = True) -> List[Dict]:
         """
-        Search termbases for matching source terms
-        
+        Search termbases for matching terms (bidirectional by default)
+
         Args:
-            search_term: Source term to search for
+            search_term: Term to search for
             source_lang: Filter by source language (optional)
             target_lang: Filter by target language (optional)
             project_id: Filter by project (optional)
             min_length: Minimum term length to return
-            
+            bidirectional: If True, also search target_term and swap results (default True)
+
         Returns:
             List of termbase hits, sorted by priority (lower = higher priority)
+            Each result includes 'match_direction' ('source' or 'target') indicating
+            which column matched. For 'target' matches, source_term and target_term
+            are swapped so results are always oriented correctly for the current project.
         """
         # Build query with filters - include termbase name and ranking via JOIN
         # Note: termbase_id is stored as TEXT in termbase_terms but INTEGER in termbases
         # Use CAST to ensure proper comparison
         # IMPORTANT: Join with termbase_activation to get the ACTUAL priority for this project
         # CRITICAL FIX: Also match when search_term starts with the glossary term
-        # This handles cases like searching for "ca." when glossary has "ca." 
+        # This handles cases like searching for "ca." when glossary has "ca."
         # AND searching for "ca" when glossary has "ca."
         # We also strip trailing punctuation from glossary terms for comparison
-        query = """
-            SELECT 
-                t.id, t.source_term, t.target_term, t.termbase_id, t.priority, 
+
+        # Build matching conditions for a given column
+        def build_match_conditions(column: str) -> str:
+            return f"""(
+                LOWER(t.{column}) = LOWER(?) OR
+                LOWER(t.{column}) LIKE LOWER(?) OR
+                LOWER(t.{column}) LIKE LOWER(?) OR
+                LOWER(t.{column}) LIKE LOWER(?) OR
+                LOWER(RTRIM(t.{column}, '.!?,;:')) = LOWER(?) OR
+                LOWER(?) LIKE LOWER(t.{column}) || '%' OR
+                LOWER(?) = LOWER(RTRIM(t.{column}, '.!?,;:'))
+            )"""
+
+        # Build match params for one direction
+        def build_match_params() -> list:
+            return [
+                search_term,
+                f"{search_term} %",
+                f"% {search_term}",
+                f"% {search_term} %",
+                search_term,  # For RTRIM comparison
+                search_term,  # For reverse LIKE
+                search_term   # For reverse RTRIM comparison
+            ]
+
+        # Matching patterns:
+        # 1. Exact match: column = search_term
+        # 2. Glossary term starts with search: column LIKE "search_term %"
+        # 3. Glossary term ends with search: column LIKE "% search_term"
+        # 4. Glossary term contains search: column LIKE "% search_term %"
+        # 5. Glossary term (stripped) = search_term: RTRIM(column) = search_term (handles "ca." = "ca")
+        # 6. Search starts with glossary term: search_term LIKE column || '%'
+        # 7. Search = glossary term stripped: search_term = RTRIM(column)
+
+        # Base SELECT for forward matches (source_term matches)
+        base_select_forward = """
+            SELECT
+                t.id, t.source_term, t.target_term, t.termbase_id, t.priority,
                 t.forbidden, t.source_lang, t.target_lang, t.definition, t.domain,
                 t.notes, t.project, t.client,
                 tb.name as termbase_name,
                 tb.source_lang as termbase_source_lang,
                 tb.target_lang as termbase_target_lang,
                 tb.is_project_termbase,
-                COALESCE(ta.priority, tb.ranking) as ranking
+                COALESCE(ta.priority, tb.ranking) as ranking,
+                'source' as match_direction
             FROM termbase_terms t
             LEFT JOIN termbases tb ON CAST(t.termbase_id AS INTEGER) = tb.id
             LEFT JOIN termbase_activation ta ON ta.termbase_id = tb.id AND ta.project_id = ? AND ta.is_active = 1
-            WHERE (
-                LOWER(t.source_term) = LOWER(?) OR 
-                LOWER(t.source_term) LIKE LOWER(?) OR 
-                LOWER(t.source_term) LIKE LOWER(?) OR 
-                LOWER(t.source_term) LIKE LOWER(?) OR
-                LOWER(RTRIM(t.source_term, '.!?,;:')) = LOWER(?) OR
-                LOWER(?) LIKE LOWER(t.source_term) || '%' OR
-                LOWER(?) = LOWER(RTRIM(t.source_term, '.!?,;:'))
-            )
+            WHERE {match_conditions}
             AND (ta.is_active = 1 OR tb.is_project_termbase = 1)
-        """
-        # Matching patterns:
-        # 1. Exact match: source_term = search_term
-        # 2. Glossary term starts with search: source_term LIKE "search_term %"
-        # 3. Glossary term ends with search: source_term LIKE "% search_term"
-        # 4. Glossary term contains search: source_term LIKE "% search_term %"
-        # 5. Glossary term (stripped) = search_term: RTRIM(source_term) = search_term (handles "ca." = "ca")
-        # 6. Search starts with glossary term: search_term LIKE source_term || '%' 
-        # 7. Search = glossary term stripped: search_term = RTRIM(source_term)
-        params = [
-            project_id if project_id else 0,  # Use 0 if no project (won't match any activation records)
-            search_term,
-            f"{search_term} %",
-            f"% {search_term}",
-            f"% {search_term} %",
-            search_term,  # For RTRIM comparison
-            search_term,  # For reverse LIKE
-            search_term   # For reverse RTRIM comparison
-        ]
-        
-        # Language filters - if term has no language, use termbase language for filtering
+        """.format(match_conditions=build_match_conditions('source_term'))
+
+        # Base SELECT for reverse matches (target_term matches) - swap source/target in output
+        base_select_reverse = """
+            SELECT
+                t.id, t.target_term as source_term, t.source_term as target_term,
+                t.termbase_id, t.priority,
+                t.forbidden, t.target_lang as source_lang, t.source_lang as target_lang,
+                t.definition, t.domain,
+                t.notes, t.project, t.client,
+                tb.name as termbase_name,
+                tb.target_lang as termbase_source_lang,
+                tb.source_lang as termbase_target_lang,
+                tb.is_project_termbase,
+                COALESCE(ta.priority, tb.ranking) as ranking,
+                'target' as match_direction
+            FROM termbase_terms t
+            LEFT JOIN termbases tb ON CAST(t.termbase_id AS INTEGER) = tb.id
+            LEFT JOIN termbase_activation ta ON ta.termbase_id = tb.id AND ta.project_id = ? AND ta.is_active = 1
+            WHERE {match_conditions}
+            AND (ta.is_active = 1 OR tb.is_project_termbase = 1)
+        """.format(match_conditions=build_match_conditions('target_term'))
+
+        # Build params
+        project_param = project_id if project_id else 0
+        forward_params = [project_param] + build_match_params()
+        reverse_params = [project_param] + build_match_params()
+
+        # Build language filter conditions
+        lang_conditions_forward = ""
+        lang_conditions_reverse = ""
+        lang_params_forward = []
+        lang_params_reverse = []
+
         if source_lang:
-            query += """ AND (
-                t.source_lang = ? OR 
+            # For forward: filter on source_lang
+            lang_conditions_forward += """ AND (
+                t.source_lang = ? OR
                 (t.source_lang IS NULL AND tb.source_lang = ?) OR
                 (t.source_lang IS NULL AND tb.source_lang IS NULL)
             )"""
-            params.extend([source_lang, source_lang])
-        
+            lang_params_forward.extend([source_lang, source_lang])
+            # For reverse: source_lang becomes target_lang (swapped)
+            lang_conditions_reverse += """ AND (
+                t.target_lang = ? OR
+                (t.target_lang IS NULL AND tb.target_lang = ?) OR
+                (t.target_lang IS NULL AND tb.target_lang IS NULL)
+            )"""
+            lang_params_reverse.extend([source_lang, source_lang])
+
         if target_lang:
-            query += """ AND (
-                t.target_lang = ? OR 
+            # For forward: filter on target_lang
+            lang_conditions_forward += """ AND (
+                t.target_lang = ? OR
                 (t.target_lang IS NULL AND tb.target_lang = ?) OR
                 (t.target_lang IS NULL AND tb.target_lang IS NULL)
             )"""
-            params.extend([target_lang, target_lang])
-        
-        # Project filter: match project-specific terms OR global terms (project_id IS NULL)
+            lang_params_forward.extend([target_lang, target_lang])
+            # For reverse: target_lang becomes source_lang (swapped)
+            lang_conditions_reverse += """ AND (
+                t.source_lang = ? OR
+                (t.source_lang IS NULL AND tb.source_lang = ?) OR
+                (t.source_lang IS NULL AND tb.source_lang IS NULL)
+            )"""
+            lang_params_reverse.extend([target_lang, target_lang])
+
+        # Project filter conditions
+        project_conditions = ""
+        project_params = []
         if project_id:
-            query += " AND (t.project_id = ? OR t.project_id IS NULL)"
-            params.append(project_id)
-        
+            project_conditions = " AND (t.project_id = ? OR t.project_id IS NULL)"
+            project_params = [project_id]
+
+        # Min length conditions
+        min_len_forward = ""
+        min_len_reverse = ""
         if min_length > 0:
-            query += f" AND LENGTH(t.source_term) >= {min_length}"
-        
-        # Sort by ranking (lower number = higher priority)
-        # Project termbases (ranking IS NULL) appear first, then by ranking, then alphabetically
-        # Use COALESCE to treat NULL as -1 (highest priority)
-        query += " ORDER BY COALESCE(tb.ranking, -1) ASC, t.source_term ASC"
-        
+            min_len_forward = f" AND LENGTH(t.source_term) >= {min_length}"
+            min_len_reverse = f" AND LENGTH(t.target_term) >= {min_length}"
+
+        # Build forward query
+        forward_query = base_select_forward + lang_conditions_forward + project_conditions + min_len_forward
+        forward_params.extend(lang_params_forward)
+        forward_params.extend(project_params)
+
+        if bidirectional:
+            # Build reverse query
+            reverse_query = base_select_reverse + lang_conditions_reverse + project_conditions + min_len_reverse
+            reverse_params.extend(lang_params_reverse)
+            reverse_params.extend(project_params)
+
+            # Combine with UNION and sort
+            query = f"""
+                SELECT * FROM (
+                    {forward_query}
+                    UNION ALL
+                    {reverse_query}
+                ) combined
+                ORDER BY COALESCE(ranking, -1) ASC, source_term ASC
+            """
+            params = forward_params + reverse_params
+        else:
+            # Original forward-only behavior
+            query = forward_query + " ORDER BY COALESCE(ranking, -1) ASC, source_term ASC"
+            params = forward_params
+
         self.cursor.execute(query, params)
         results = []
+        seen_combinations = set()  # Track (source_term, target_term, termbase_id) to avoid duplicates
+
         for row in self.cursor.fetchall():
             result_dict = dict(row)
+
+            # Deduplicate: same term pair from same termbase should only appear once
+            # Prefer 'source' match over 'target' match
+            combo_key = (
+                result_dict.get('source_term', '').lower(),
+                result_dict.get('target_term', '').lower(),
+                result_dict.get('termbase_id')
+            )
+            if combo_key in seen_combinations:
+                continue
+            seen_combinations.add(combo_key)
+
             # SQLite stores booleans as 0/1, explicitly convert to Python bool
             if 'is_project_termbase' in result_dict:
                 result_dict['is_project_termbase'] = bool(result_dict['is_project_termbase'])
-            
+
             # Fetch target synonyms for this term and include them in the result
             term_id = result_dict.get('id')
+            match_direction = result_dict.get('match_direction', 'source')
             if term_id:
                 try:
+                    # For reverse matches, fetch 'source' synonyms since they become targets
+                    synonym_lang = 'source' if match_direction == 'target' else 'target'
                     self.cursor.execute("""
                         SELECT synonym_text, forbidden FROM termbase_synonyms
-                        WHERE term_id = ? AND language = 'target'
+                        WHERE term_id = ? AND language = ?
                         ORDER BY display_order ASC
-                    """, (term_id,))
+                    """, (term_id, synonym_lang))
                     synonyms = []
                     for syn_row in self.cursor.fetchall():
                         syn_text = syn_row[0]
@@ -1600,7 +1705,7 @@ class DatabaseManager:
                     result_dict['target_synonyms'] = synonyms
                 except Exception:
                     result_dict['target_synonyms'] = []
-            
+
             results.append(result_dict)
         return results
     

modules/mqxliff_handler.py

@@ -159,9 +159,78 @@ class MQXLIFFHandler:
                 
                 segment = FormattedSegment(trans_unit_id, plain_text, formatted_xml)
                 segments.append(segment)
-        
+
         return segments
-    
+
+    def extract_bilingual_segments(self) -> List[Dict]:
+        """
+        Extract all source AND target segments from the MQXLIFF file.
+        Used for importing pretranslated mqxliff files.
+
+        Returns:
+            List of dicts with 'id', 'source', 'target', 'status' keys
+        """
+        segments = []
+
+        if self.body_element is None:
+            return segments
+
+        # Find all trans-unit elements (with or without namespace)
+        trans_units = self.body_element.findall('.//xliff:trans-unit', self.NAMESPACES)
+        if not trans_units:
+            trans_units = self.body_element.findall('.//trans-unit')
+
+        for trans_unit in trans_units:
+            trans_unit_id = trans_unit.get('id', 'unknown')
+
+            # Skip auxiliary segments (like hyperlink URLs with mq:nosplitjoin="true")
+            nosplitjoin = trans_unit.get('{MQXliff}nosplitjoin', 'false')
+            if nosplitjoin == 'true':
+                continue
+
+            # Find source element
+            source_elem = trans_unit.find('xliff:source', self.NAMESPACES)
+            if source_elem is None:
+                source_elem = trans_unit.find('source')
+
+            # Find target element
+            target_elem = trans_unit.find('xliff:target', self.NAMESPACES)
+            if target_elem is None:
+                target_elem = trans_unit.find('target')
+
+            source_text = ""
+            target_text = ""
+
+            if source_elem is not None:
+                source_text = self._extract_plain_text(source_elem)
+
+            if target_elem is not None:
+                target_text = self._extract_plain_text(target_elem)
+
+            # Get memoQ status if available
+            mq_status = trans_unit.get('{MQXliff}status', '')
+
+            # Map memoQ status to internal status
+            # memoQ statuses: "NotStarted", "Editing", "Confirmed", "Reviewed", "Rejected", etc.
+            status = 'not_started'
+            if mq_status in ['Confirmed', 'ProofRead', 'Reviewed']:
+                status = 'confirmed'
+            elif mq_status == 'Editing':
+                status = 'translated'
+            elif target_text.strip():
+                # Has target but unknown status - mark as pre-translated
+                status = 'pre_translated'
+
+            segments.append({
+                'id': trans_unit_id,
+                'source': source_text,
+                'target': target_text,
+                'status': status,
+                'mq_status': mq_status
+            })
+
+        return segments
+
     def _extract_plain_text(self, element: ET.Element) -> str:
         """
         Recursively extract plain text from an XML element, stripping all tags.

modules/tm_metadata_manager.py

@@ -344,19 +344,22 @@ class TMMetadataManager:
         """Check if a TM is active for a project (or global when project_id=0)"""
         if project_id is None:
             return False  # If None (not 0), default to inactive
-        
+
         try:
             cursor = self.db_manager.cursor
-            
+
+            # Check if TM is active for this project OR globally (project_id=0)
             cursor.execute("""
-                SELECT is_active FROM tm_activation 
-                WHERE tm_id = ? AND project_id = ?
+                SELECT is_active FROM tm_activation
+                WHERE tm_id = ? AND (project_id = ? OR project_id = 0)
+                ORDER BY project_id DESC
             """, (tm_db_id, project_id))
-            
-            row = cursor.fetchone()
-            if row:
-                return bool(row[0])
-            
+
+            # Return True if any activation is active (project-specific takes priority due to ORDER BY)
+            for row in cursor.fetchall():
+                if bool(row[0]):
+                    return True
+
             # If no activation record exists, TM is inactive by default
             return False
         except Exception as e:
@@ -382,15 +385,16 @@ class TMMetadataManager:
         
         try:
             cursor = self.db_manager.cursor
-            
+
             # Only return TMs that have been explicitly activated (is_active = 1)
+            # Include both project-specific activations AND global activations (project_id=0)
             cursor.execute("""
-                SELECT tm.tm_id 
+                SELECT DISTINCT tm.tm_id
                 FROM translation_memories tm
                 INNER JOIN tm_activation ta ON tm.id = ta.tm_id
-                WHERE ta.project_id = ? AND ta.is_active = 1
+                WHERE (ta.project_id = ? OR ta.project_id = 0) AND ta.is_active = 1
             """, (project_id,))
-            
+
             return [row[0] for row in cursor.fetchall()]
         except Exception as e:
             self.log(f"✗ Error fetching active tm_ids: {e}")
@@ -422,16 +426,17 @@ class TMMetadataManager:
         
         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
+            # AND the TM has an activation record for this project OR for global (project_id=0)
+            # This ensures TMs created when no project was loaded still work
             cursor.execute("""
-                SELECT tm.tm_id 
+                SELECT DISTINCT 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
+                WHERE (ta.project_id = ? OR ta.project_id = 0) 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}")

{supervertaler-1.9.176b0.dist-info → supervertaler-1.9.178.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supervertaler
-Version: 1.9.176b0
+Version: 1.9.178
 Summary: Professional AI-enhanced translation workbench with multi-LLM support, glossary system, TM, spellcheck, voice commands, and PyQt6 interface. Batteries included (core).
 Home-page: https://supervertaler.com
 Author: Michael Beijer

{supervertaler-1.9.176b0.dist-info → supervertaler-1.9.178.dist-info}/RECORD

@@ -1,4 +1,4 @@
-Supervertaler.py,sha256=ABqaS7k80j4w3EiJr52ogQVIJRAFFOD3NpaeDbzWX6k,2318994
+Supervertaler.py,sha256=24LuStpwkjEpgE9gA0ng57sIJgOTkXS15riRgt-eSRM,2324855
 modules/__init__.py,sha256=G58XleS-EJ2sX4Kehm-3N2m618_W2Es0Kg8CW_eBG7g,327
 modules/ai_actions.py,sha256=i5MJcM-7Y6CAvKUwxmxrVHeoZAVtAP7aRDdWM5KLkO0,33877
 modules/ai_attachment_manager.py,sha256=juZlrW3UPkIkcnj0SREgOQkQROLf0fcu3ShZcKXMxsI,11361
@@ -6,7 +6,7 @@ modules/ai_file_viewer_dialog.py,sha256=lKKqUUlOEVgHmmu6aRxqH7P6ds-7dRLk4ltDyjCw
 modules/autofingers_engine.py,sha256=eJ7tBi7YJvTToe5hYTfnyGXB-qme_cHrOPZibaoR2Xw,17061
 modules/cafetran_docx_handler.py,sha256=_F7Jh0WPVaDnMhdxEsVSXuD1fN9r-S_V6i0gr86Pdfc,14076
 modules/config_manager.py,sha256=MkPY3xVFgFDkcwewLREg4BfyKueO0OJkT1cTLxehcjM,17894
-modules/database_manager.py,sha256=FecvNLJa_mw0PZld8-LozUSSgtAq6wDZ8Mhq_u2aiA0,82563
+modules/database_manager.py,sha256=yNtaJNAKtICBBSc5iyhIufzDn25k7OqkOuFeojmWuM4,87319
 modules/database_migrations.py,sha256=tndJ4wV_2JBfPggMgO1tQRwdfRFZ9zwvADllCZE9CCk,15663
 modules/dejavurtf_handler.py,sha256=8NZPPYtHga40SZCypHjPoJPmZTvm9rD-eEUUab7mjtg,28156
 modules/document_analyzer.py,sha256=t1rVvqLaTcpQTEja228C7zZnh8dXshK4wA9t1E9aGVk,19524
@@ -28,7 +28,7 @@ modules/llm_superbench_ui.py,sha256=lmzsL8lt0KzFw-z8De1zb49Emnv7f1dZv_DJmoQz0bQ,
 modules/local_llm_setup.py,sha256=33y-D_LKzkn2w8ejyjeKaovf_An6xQ98mKISoqe-Qjc,42661
 modules/model_update_dialog.py,sha256=kEg0FuO1N-uj6QY5ZIj-FqdiLQuPuAY48pbuwT0HUGI,13113
 modules/model_version_checker.py,sha256=41g7gcWvyrKPYeobaOGCMZLwAHgQmFwVF8zokodKae8,12741
-modules/mqxliff_handler.py,sha256=-tUFubKsxkx6nW7aMDhuDaTBcVTPtVHV1HyzF0TbkVo,26205
+modules/mqxliff_handler.py,sha256=TVtrf7ieGoxfoLxy4v4S7by9YImKypw1EY0wFpZO3Lo,28792
 modules/non_translatables_manager.py,sha256=izorabiX6rSQzuBIvnY67wmu5vd85SbzexXccbmwPs4,27465
 modules/pdf_rescue_Qt.py,sha256=9W_M0Zms4miapQbrqm-viHNCpaW39GL9VaKKFCJxpnE,80479
 modules/pdf_rescue_tkinter.py,sha256=a4R_OUnn7X5O_XMR1roybrdu1aXoGCwwO-mwYB2ZpOg,39606
@@ -63,7 +63,7 @@ modules/termview_widget.py,sha256=O3ah7g-4Lb_iUctxl9sMyxh8V3A5I5PFxmy9iIH2Kgk,53
 modules/theme_manager.py,sha256=EOI_5pM2bXAadw08bbl92TLN-w28lbw4Zi1E8vQ-kM0,16694
 modules/tm_editor_dialog.py,sha256=AzGwq4QW641uFJdF8DljLTRRp4FLoYX3Pe4rlTjQWNg,3517
 modules/tm_manager_qt.py,sha256=h2bvXkRuboHf_RRz9-5FX35GVRlpXgRDWeXyj1QWtPs,54406
-modules/tm_metadata_manager.py,sha256=_drzJ80q-mr1y9La8t0Cb8MXh91n3I-lEGDwSmoVI_4,23161
+modules/tm_metadata_manager.py,sha256=NTsaI_YjQnVOpU_scAwK9uR1Tcl9pzKD1GwLVy7sx2g,23590
 modules/tmx_editor.py,sha256=n0CtdZI8f1fPRWmCqz5Ysxbnp556Qj-6Y56a-YIz6pY,59239
 modules/tmx_editor_qt.py,sha256=PxBIUw_06PHYTBHsd8hZzVJXW8T0A0ljfz1Wjjsa4yU,117022
 modules/tmx_generator.py,sha256=pNkxwdMLvSRMMru0lkB1gvViIpg9BQy1EVhRbwoef3k,9426
@@ -77,9 +77,9 @@ modules/unified_prompt_manager_qt.py,sha256=U89UFGG-M7BLetoaLAlma0x-n8SIyx682DhS
 modules/voice_commands.py,sha256=iBb-gjWxRMLhFH7-InSRjYJz1EIDBNA2Pog8V7TtJaY,38516
 modules/voice_dictation.py,sha256=QmitXfkG-vRt5hIQATjphHdhXfqmwhzcQcbXB6aRzIg,16386
 modules/voice_dictation_lite.py,sha256=jorY0BmWE-8VczbtGrWwt1zbnOctMoSlWOsQrcufBcc,9423
-supervertaler-1.9.176b0.dist-info/licenses/LICENSE,sha256=m28u-4qL5nXIWnJ6xlQVw__H30rWFtRK3pCOais2OuY,1092
-supervertaler-1.9.176b0.dist-info/METADATA,sha256=NXnmveUpuH50y_2kAdkEavCbLiRpDYAUSIIc7YK0d-8,5727
-supervertaler-1.9.176b0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-supervertaler-1.9.176b0.dist-info/entry_points.txt,sha256=NP4hiCvx-_30YYKqgr-jfJYQvHr1qTYBMfoVmKIXSM8,53
-supervertaler-1.9.176b0.dist-info/top_level.txt,sha256=9tUHBYUSfaE4S2E4W3eavJsDyYymkwLfeWAHHAPT6Dk,22
-supervertaler-1.9.176b0.dist-info/RECORD,,
+supervertaler-1.9.178.dist-info/licenses/LICENSE,sha256=m28u-4qL5nXIWnJ6xlQVw__H30rWFtRK3pCOais2OuY,1092
+supervertaler-1.9.178.dist-info/METADATA,sha256=xnzgsUbZYFuATYJ-szDvevswcXb94_u7lC33CAzW-1A,5725
+supervertaler-1.9.178.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+supervertaler-1.9.178.dist-info/entry_points.txt,sha256=NP4hiCvx-_30YYKqgr-jfJYQvHr1qTYBMfoVmKIXSM8,53
+supervertaler-1.9.178.dist-info/top_level.txt,sha256=9tUHBYUSfaE4S2E4W3eavJsDyYymkwLfeWAHHAPT6Dk,22
+supervertaler-1.9.178.dist-info/RECORD,,