supervertaler 1.9.176b0__tar.gz → 1.9.177b0__tar.gz

{supervertaler-1.9.176b0 → supervertaler-1.9.177b0}/CHANGELOG.md

@@ -2,10 +2,18 @@
 
 All notable changes to Supervertaler are documented in this file.
 
-**Current Version:** v1.9.176-beta (January 28, 2026)
+**Current Version:** v1.9.177-beta (January 28, 2026)
 
 
 
+## v1.9.177-beta - January 28, 2026
+
+### ✨ New Features
+
+- **Bidirectional Termbase Matching**: Glossaries now work like memoQ and Trados - a termbase created for NL→EN will also find matches when working on EN→NL projects (and vice versa). This "direction-insensitive" behavior means you no longer need separate termbases for different language directions. When a match is found on the target side, source and target are automatically swapped in the results.
+
+---
+
 ## v1.9.176-beta - January 28, 2026
 
 ### ✨ New Features

{supervertaler-1.9.176b0 → supervertaler-1.9.177b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supervertaler
-Version: 1.9.176b0
+Version: 1.9.177b0
 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 → supervertaler-1.9.177b0}/Supervertaler.py

@@ -22319,20 +22319,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 +22356,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 +22383,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 +22445,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 +22457,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 +22477,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']

{supervertaler-1.9.176b0 → supervertaler-1.9.177b0}/docs/index.html

@@ -17,7 +17,7 @@
     <link rel="apple-touch-icon" href="apple-touch-icon.png">
     <link rel="manifest" href="site.webmanifest">
 
-    <link rel="stylesheet" href="styles.css?v=1.9.176-beta">
+    <link rel="stylesheet" href="styles.css?v=1.9.177-beta">
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap"
@@ -50,7 +50,7 @@
                         class="nav-discussions">💬 Discussions</a></li>
                 <li class="nav-action">
                     <a href="https://github.com/michaelbeijer/Supervertaler/blob/main/CHANGELOG.md" target="_blank"
-                        class="nav-version" title="Current version">v1.9.176-beta</a>
+                        class="nav-version" title="Current version">v1.9.177-beta</a>
                 </li>
                 <li class="nav-action">
                     <a href="https://github.com/michaelbeijer/Supervertaler" target="_blank" class="nav-icon-link"
@@ -74,7 +74,7 @@
                     Supervertaler
                     <span class="gradient-text">The Ultimate Translation Workbench</span>
                 </h1>
-                <p class="version-badge">v1.9.176-beta</p>
+                <p class="version-badge">v1.9.177-beta</p>
                 <p class="hero-subtitle">
                     AI-enhanced translation workbench. Work with ChatGPT, Claude, and Gemini simultaneously.
                     Built by translators, for translators and writers.
@@ -711,7 +711,7 @@
             <div style="text-align: center; margin: 40px 0;">
                 <div class="download-card featured"
                     style="border: 3px solid #6366F1; max-width: 700px; margin: 0 auto;">
-                    <div class="download-badge" style="background: #6366F1;">v1.9.176-beta</div>
+                    <div class="download-badge" style="background: #6366F1;">v1.9.177-beta</div>
                     <h3>🎨 Supervertaler</h3>
                     <p class="download-description" style="font-weight: 600; color: #6366F1; margin-bottom: 10px;">
                         Modern Professional Interface

{supervertaler-1.9.176b0 → supervertaler-1.9.177b0}/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
     

{supervertaler-1.9.176b0 → supervertaler-1.9.177b0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "supervertaler"
-version = "1.9.176-beta"
+version = "1.9.177-beta"
 description = "Professional AI-enhanced translation workbench with multi-LLM support, glossary system, TM, spellcheck, voice commands, and PyQt6 interface. Batteries included (core)."
 readme = "README.md"
 requires-python = ">=3.10"

{supervertaler-1.9.176b0 → supervertaler-1.9.177b0}/supervertaler.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supervertaler
-Version: 1.9.176b0
+Version: 1.9.177b0
 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