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

modules/ai_attachment_manager.py

@@ -29,15 +29,15 @@ class AttachmentManager:
         Initialize the AttachmentManager.
 
         Args:
-            base_dir: Base directory for attachments (default: user_data_private/AI_Assistant)
+            base_dir: Base directory for attachments (default: user_data_private/ai_assistant)
             log_callback: Function to call for logging messages
         """
         self.log = log_callback if log_callback else print
 
         # Set base directory
         if base_dir is None:
-            # Default to user_data_private/AI_Assistant
-            base_dir = Path("user_data_private") / "AI_Assistant"
+            # Default to user_data_private/ai_assistant
+            base_dir = Path("user_data_private") / "ai_assistant"
 
         self.base_dir = Path(base_dir)
         self.attachments_dir = self.base_dir / "attachments"

modules/config_manager.py

@@ -35,14 +35,14 @@ class ConfigManager:
     REQUIRED_FOLDERS = [
         # Note: Old numbered folders (1_System_Prompts, 2_Domain_Prompts, etc.) are deprecated
         # Migration moves them to unified Library structure
-        "Prompt_Library/Domain Expertise",
-        "Prompt_Library/Project Prompts",
-        "Prompt_Library/Style Guides",
-        "Translation_Resources/Termbases",
-        "Translation_Resources/TMs",
-        "Translation_Resources/Non-translatables",
-        "Translation_Resources/Segmentation_rules",
-        "Projects",
+        "prompt_library/domain_expertise",
+        "prompt_library/project_prompts",
+        "prompt_library/style_guides",
+        "resources/termbases",
+        "resources/tms",
+        "resources/non_translatables",
+        "resources/segmentation_rules",
+        "projects",
     ]
     
     def __init__(self):
@@ -268,8 +268,8 @@ class ConfigManager:
         Get the full path to a subfolder in user_data.
         
         Example:
-            config.get_subfolder_path('Translation_Resources/TMs')
-            -> '/home/user/Supervertaler_Data/Translation_Resources/TMs'
+            config.get_subfolder_path('resources/tms')
+            -> '/home/user/Supervertaler/resources/tms'
         """
         user_data_path = self.get_user_data_path()
         full_path = os.path.join(user_data_path, subfolder)

modules/database_manager.py

@@ -17,12 +17,38 @@ import sqlite3
 import os
 import json
 import hashlib
+import unicodedata
+import re
 from datetime import datetime
 from typing import List, Dict, Optional, Tuple
 from pathlib import Path
 from difflib import SequenceMatcher
 
 
+def _normalize_for_matching(text: str) -> str:
+    """Normalize text for exact matching.
+
+    Handles invisible differences that would cause exact match to fail:
+    - Unicode normalization (NFC)
+    - Multiple whitespace -> single space
+    - Leading/trailing whitespace
+    - Non-breaking spaces -> regular spaces
+    """
+    if not text:
+        return ""
+    # Unicode normalize (NFC form)
+    text = unicodedata.normalize('NFC', text)
+    # Convert non-breaking spaces and other whitespace to regular space
+    text = text.replace('\u00a0', ' ')  # NBSP
+    text = text.replace('\u2007', ' ')  # Figure space
+    text = text.replace('\u202f', ' ')  # Narrow NBSP
+    # Collapse multiple whitespace to single space
+    text = re.sub(r'\s+', ' ', text)
+    # Strip leading/trailing whitespace
+    text = text.strip()
+    return text
+
+
 class DatabaseManager:
     """Manages SQLite database for translation resources"""
     
@@ -655,17 +681,19 @@ class DatabaseManager:
     # TRANSLATION MEMORY METHODS
     # ============================================
     
-    def add_translation_unit(self, source: str, target: str, source_lang: str, 
+    def add_translation_unit(self, source: str, target: str, source_lang: str,
                             target_lang: str, tm_id: str = 'project',
                             project_id: str = None, context_before: str = None,
                             context_after: str = None, notes: str = None) -> int:
         """
         Add translation unit to database
-        
+
         Returns: ID of inserted/updated entry
         """
-        # Generate hash for fast exact matching
-        source_hash = hashlib.md5(source.encode('utf-8')).hexdigest()
+        # Generate hash from NORMALIZED source for consistent exact matching
+        # This handles invisible differences like Unicode normalization, whitespace variations
+        normalized_source = _normalize_for_matching(source)
+        source_hash = hashlib.md5(normalized_source.encode('utf-8')).hexdigest()
         
         try:
             self.cursor.execute("""
@@ -687,33 +715,38 @@ class DatabaseManager:
             return None
     
     def get_exact_match(self, source: str, tm_ids: List[str] = None,
-                       source_lang: str = None, target_lang: str = None, 
+                       source_lang: str = None, target_lang: str = None,
                        bidirectional: bool = True) -> Optional[Dict]:
         """
         Get exact match from TM
-        
+
         Args:
             source: Source text to match
             tm_ids: List of TM IDs to search (None = all)
             source_lang: Filter by source language (base code matching: 'en' matches 'en-US', 'en-GB', etc.)
             target_lang: Filter by target language (base code matching)
             bidirectional: If True, search both directions (nl→en AND en→nl)
-        
+
         Returns: Dictionary with match data or None
         """
         from modules.tmx_generator import get_base_lang_code
-        
+
+        # Try both normalized and non-normalized hashes for backward compatibility
+        # This handles invisible differences like Unicode normalization, whitespace variations
         source_hash = hashlib.md5(source.encode('utf-8')).hexdigest()
-        
+        normalized_source = _normalize_for_matching(source)
+        normalized_hash = hashlib.md5(normalized_source.encode('utf-8')).hexdigest()
+
         # Get base language codes for comparison
         src_base = get_base_lang_code(source_lang) if source_lang else None
         tgt_base = get_base_lang_code(target_lang) if target_lang else None
-        
+
+        # Search using both original hash and normalized hash
         query = """
-            SELECT * FROM translation_units 
-            WHERE source_hash = ? AND source_text = ?
+            SELECT * FROM translation_units
+            WHERE (source_hash = ? OR source_hash = ?)
         """
-        params = [source_hash, source]
+        params = [source_hash, normalized_hash]
         
         if tm_ids:
             placeholders = ','.join('?' * len(tm_ids))
@@ -840,11 +873,15 @@ class DatabaseManager:
             bidirectional: If True, search both directions (nl→en AND en→nl)
         
         Returns: List of matches with similarity scores
+        
+        Note: When multiple TMs are provided, searches each TM separately to ensure
+        good matches from smaller TMs aren't pushed out by BM25 keyword ranking
+        from larger TMs. Results are merged and sorted by actual similarity.
         """
         # For better FTS5 matching, tokenize the query and escape special chars
         # FTS5 special characters: " ( ) - : , . ! ? 
         import re
-        from modules.tmx_generator import get_base_lang_code
+        from modules.tmx_generator import get_base_lang_code, get_lang_match_variants
         
         # Strip HTML/XML tags from source for clean text search
         text_without_tags = re.sub(r'<[^>]+>', '', source)
@@ -868,22 +905,57 @@ class DatabaseManager:
         # This helps find similar long segments more reliably
         search_terms_for_query = all_search_terms[:20]
         
-        print(f"[DEBUG] search_fuzzy_matches: source='{source[:50]}...', {len(all_search_terms)} terms")
-        
         if not search_terms_for_query:
             # If no valid terms, return empty results
-            print(f"[DEBUG] search_fuzzy_matches: No valid search terms, returning empty")
             return []
         
         # Quote each term to prevent FTS5 syntax errors
         fts_query = ' OR '.join(f'"{term}"' for term in search_terms_for_query)
-        print(f"[DEBUG] search_fuzzy_matches: FTS query terms = {search_terms_for_query[:10]}...")
         
         # Get base language codes for comparison
         src_base = get_base_lang_code(source_lang) if source_lang else None
         tgt_base = get_base_lang_code(target_lang) if target_lang else None
         
-        # Use FTS5 for initial candidate retrieval (fast)
+        # MULTI-TM FIX: Search each TM separately to avoid BM25 ranking issues
+        # When a large TM is combined with a small TM, the large TM's many keyword matches
+        # push down genuinely similar sentences from the small TM
+        tms_to_search = tm_ids if tm_ids else [None]  # None means search all TMs together
+        
+        all_results = []
+        
+        for tm_id in tms_to_search:
+            # Search this specific TM (or all if tm_id is None)
+            tm_results = self._search_single_tm_fuzzy(
+                source, fts_query, [tm_id] if tm_id else None,
+                threshold, max_results, src_base, tgt_base, 
+                source_lang, target_lang, bidirectional
+            )
+            all_results.extend(tm_results)
+        
+        # Deduplicate by source_text (keep highest similarity for each unique source)
+        seen = {}
+        for result in all_results:
+            key = result['source_text']
+            if key not in seen or result['similarity'] > seen[key]['similarity']:
+                seen[key] = result
+        
+        deduped_results = list(seen.values())
+        
+        # Sort ALL results by similarity (highest first) - this ensures the 76% match
+        # appears before 40% matches regardless of which TM they came from
+        deduped_results.sort(key=lambda x: x['similarity'], reverse=True)
+        
+        return deduped_results[:max_results]
+    
+    def _search_single_tm_fuzzy(self, source: str, fts_query: str, tm_ids: List[str],
+                                 threshold: float, max_results: int,
+                                 src_base: str, tgt_base: str,
+                                 source_lang: str, target_lang: str,
+                                 bidirectional: bool) -> List[Dict]:
+        """Search a single TM (or all TMs if tm_ids is None) for fuzzy matches"""
+        from modules.tmx_generator import get_lang_match_variants
+        
+        # Build query for this TM
         query = """
             SELECT tu.*, 
                    bm25(translation_units_fts) as relevance
@@ -893,13 +965,12 @@ class DatabaseManager:
         """
         params = [fts_query]
         
-        if tm_ids:
+        if tm_ids and tm_ids[0] is not None:
             placeholders = ','.join('?' * len(tm_ids))
             query += f" AND tu.tm_id IN ({placeholders})"
             params.extend(tm_ids)
         
         # Use flexible language matching (matches 'nl', 'nl-NL', 'Dutch', etc.)
-        from modules.tmx_generator import get_lang_match_variants
         if src_base:
             src_variants = get_lang_match_variants(source_lang)
             src_conditions = []
@@ -920,19 +991,16 @@ class DatabaseManager:
                 params.append(f"{variant}-%")
             query += f" AND ({' OR '.join(tgt_conditions)})"
         
-        # Get more candidates than needed for proper scoring (increase limit for long segments)
-        # Long segments need MANY more candidates because BM25 ranking may push down
-        # the truly similar entries in favor of entries matching more search terms
+        # Per-TM candidate limit - INCREASED to catch more potential fuzzy matches
+        # When multiple TMs are searched, BM25 ranking can push genuinely similar
+        # entries far down the list due to common word matches in other entries
         candidate_limit = max(500, max_results * 50)
         query += f" ORDER BY relevance DESC LIMIT {candidate_limit}"
         
-        print(f"[DEBUG] search_fuzzy_matches: Executing query (limit={candidate_limit})...")
-        
         try:
             self.cursor.execute(query, params)
             all_rows = self.cursor.fetchall()
         except Exception as e:
-            print(f"[DEBUG] search_fuzzy_matches: SQL ERROR: {e}")
             return []
         
         results = []
@@ -948,8 +1016,6 @@ class DatabaseManager:
                 match_dict['match_pct'] = int(similarity * 100)
                 results.append(match_dict)
         
-        print(f"[DEBUG] search_fuzzy_matches: After threshold filter ({threshold}): {len(results)} matches")
-        
         # If bidirectional, also search reverse direction
         if bidirectional and src_base and tgt_base:
             query = """
@@ -961,13 +1027,12 @@ class DatabaseManager:
             """
             params = [fts_query]
             
-            if tm_ids:
+            if tm_ids and tm_ids[0] is not None:
                 placeholders = ','.join('?' * len(tm_ids))
                 query += f" AND tu.tm_id IN ({placeholders})"
                 params.extend(tm_ids)
             
             # Reversed language filters with flexible matching
-            # For reverse: TM target_lang should match our source_lang, TM source_lang should match our target_lang
             src_variants = get_lang_match_variants(source_lang)
             tgt_variants = get_lang_match_variants(target_lang)
             
@@ -991,26 +1056,27 @@ class DatabaseManager:
             
             query += f" ORDER BY relevance DESC LIMIT {max_results * 5}"
             
-            self.cursor.execute(query, params)
-            
-            for row in self.cursor.fetchall():
-                match_dict = dict(row)
-                # Calculate similarity against target_text (since we're reversing)
-                similarity = self.calculate_similarity(source, match_dict['target_text'])
+            try:
+                self.cursor.execute(query, params)
                 
-                # Only include matches above threshold
-                if similarity >= threshold:
-                    # Swap source/target for reverse match
-                    match_dict['source_text'], match_dict['target_text'] = match_dict['target_text'], match_dict['source_text']
-                    match_dict['source_lang'], match_dict['target_lang'] = match_dict['target_lang'], match_dict['source_lang']
-                    match_dict['similarity'] = similarity
-                    match_dict['match_pct'] = int(similarity * 100)
-                    match_dict['reverse_match'] = True
-                    results.append(match_dict)
-        
-        # Sort by similarity (highest first) and limit results
-        results.sort(key=lambda x: x['similarity'], reverse=True)
-        return results[:max_results]
+                for row in self.cursor.fetchall():
+                    match_dict = dict(row)
+                    # Calculate similarity against target_text (since we're reversing)
+                    similarity = self.calculate_similarity(source, match_dict['target_text'])
+                    
+                    # Only include matches above threshold
+                    if similarity >= threshold:
+                        # Swap source/target for reverse match
+                        match_dict['source_text'], match_dict['target_text'] = match_dict['target_text'], match_dict['source_text']
+                        match_dict['source_lang'], match_dict['target_lang'] = match_dict['target_lang'], match_dict['source_lang']
+                        match_dict['similarity'] = similarity
+                        match_dict['match_pct'] = int(similarity * 100)
+                        match_dict['reverse_match'] = True
+                        results.append(match_dict)
+            except Exception as e:
+                print(f"[DEBUG] _search_single_tm_fuzzy (reverse): SQL ERROR: {e}")
+        
+        return results
     
     def search_all(self, source: str, tm_ids: List[str] = None, enabled_only: bool = True,
                    threshold: float = 0.75, max_results: int = 10) -> List[Dict]:
@@ -1124,6 +1190,12 @@ class DatabaseManager:
         Uses FTS5 full-text search for fast matching on millions of segments.
         Falls back to LIKE queries if FTS5 fails.
         
+        Language filters define what you're searching FOR and what translation you want:
+        - "From: Dutch, To: English" = Search for Dutch text, show English translations
+        - Searches ALL TMs (regardless of their stored language pair direction)
+        - Automatically swaps columns when needed (e.g., finds Dutch in target column of EN→NL TM)
+        - This is MORE intuitive than traditional CAT tools that only search specific TM directions
+        
         Args:
             query: Text to search for
             tm_ids: List of TM IDs to search (None = all)
@@ -1141,6 +1213,12 @@ class DatabaseManager:
         # Wrap in quotes for phrase search
         fts_query = f'"{fts_query}"'
         
+        # When language filters specified, we need to search intelligently:
+        # - Don't filter by TM language pair (search ALL TMs)
+        # - Search in BOTH columns to find text
+        # - Swap columns if needed to show correct language order
+        use_smart_search = (source_langs or target_langs)
+        
         try:
             # Use FTS5 for fast full-text search
             if direction == 'source':
@@ -1171,20 +1249,105 @@ class DatabaseManager:
                 fts_sql += f" AND tu.tm_id IN ({placeholders})"
                 params.extend(tm_ids)
             
-            # Add language filters (support for list of variants)
-            if source_langs:
-                placeholders = ','.join('?' * len(source_langs))
-                fts_sql += f" AND tu.source_lang IN ({placeholders})"
-                params.extend(source_langs)
-            if target_langs:
-                placeholders = ','.join('?' * len(target_langs))
-                fts_sql += f" AND tu.target_lang IN ({placeholders})"
-                params.extend(target_langs)
+            # DON'T filter by language when smart search active
+            # (we need to search all TMs and figure out which column has our language)
+            if not use_smart_search:
+                # Traditional filtering when no language filters
+                if source_langs:
+                    placeholders = ','.join('?' * len(source_langs))
+                    fts_sql += f" AND tu.source_lang IN ({placeholders})"
+                    params.extend(source_langs)
+                if target_langs:
+                    placeholders = ','.join('?' * len(target_langs))
+                    fts_sql += f" AND tu.target_lang IN ({placeholders})"
+                    params.extend(target_langs)
             
             fts_sql += " ORDER BY tu.modified_date DESC LIMIT 100"
             
             self.cursor.execute(fts_sql, params)
-            return [dict(row) for row in self.cursor.fetchall()]
+            raw_results = [dict(row) for row in self.cursor.fetchall()]
+            
+            # Smart search: Filter and swap based on language metadata
+            if use_smart_search:
+                processed_results = []
+                for row in raw_results:
+                    row_src_lang = row.get('source_lang', '')
+                    row_tgt_lang = row.get('target_lang', '')
+                    
+                    # Check if this row matches our language requirements
+                    # If "From: Dutch, To: English":
+                    # - Accept if source=nl and target=en (normal)
+                    # - Accept if source=en and target=nl (swap needed)
+                    
+                    matches = False
+                    needs_swap = False
+                    
+                    if source_langs and target_langs:
+                        # Both filters specified
+                        if row_src_lang in source_langs and row_tgt_lang in target_langs:
+                            # Perfect match - no swap
+                            matches = True
+                            needs_swap = False
+                        elif row_src_lang in target_langs and row_tgt_lang in source_langs:
+                            # Reversed - needs swap
+                            matches = True
+                            needs_swap = True
+                    elif source_langs:
+                        # Only "From" specified - just check if Dutch is in EITHER column
+                        if row_src_lang in source_langs:
+                            matches = True
+                            needs_swap = False
+                        elif row_tgt_lang in source_langs:
+                            matches = True
+                            needs_swap = True
+                    elif target_langs:
+                        # Only "To" specified - just check if English is in EITHER column
+                        if row_tgt_lang in target_langs:
+                            matches = True
+                            needs_swap = False
+                        elif row_src_lang in target_langs:
+                            matches = True
+                            needs_swap = True
+                    
+                    if matches:
+                        # CRITICAL CHECK: Verify the search text is actually in the correct column
+                        # If user searches for Dutch with "From: Dutch", the text must be in the source column (after any swap)
+                        # This prevents finding Dutch text when user asks to search FOR English
+                        
+                        if needs_swap:
+                            # After swap, check if query is in the NEW source column (was target)
+                            text_to_check = row['target_text'].lower()
+                        else:
+                            # No swap, check if query is in source column
+                            text_to_check = row['source_text'].lower()
+                        
+                        # Only include if query text is actually in the source column
+                        if query.lower() in text_to_check:
+                            if needs_swap:
+                                # Swap columns to show correct language order
+                                swapped_row = row.copy()
+                                swapped_row['source'] = row['target_text']
+                                swapped_row['target'] = row['source_text']
+                                swapped_row['source_lang'] = row['target_lang']
+                                swapped_row['target_lang'] = row['source_lang']
+                                processed_results.append(swapped_row)
+                            else:
+                                # No swap needed - just rename columns
+                                processed_row = row.copy()
+                                processed_row['source'] = row['source_text']
+                                processed_row['target'] = row['target_text']
+                                processed_results.append(processed_row)
+                
+                return processed_results
+            else:
+                # No language filters - just rename columns
+                processed_results = []
+                for row in raw_results:
+                    processed_row = row.copy()
+                    processed_row['source'] = row['source_text']
+                    processed_row['target'] = row['target_text']
+                    processed_results.append(processed_row)
+                return processed_results
             
         except Exception as e:
             # Fallback to LIKE query if FTS5 fails (e.g., index not built)
@@ -1312,6 +1475,10 @@ class DatabaseManager:
         # 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." 
+        # 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, 
@@ -1329,19 +1496,30 @@ class DatabaseManager:
                 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(?)
+                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, '.!?,;:'))
             )
             AND (ta.is_active = 1 OR tb.is_project_termbase = 1)
         """
-        # Exact match, word at start, word at end, word in middle
-        # Use LOWER() for case-insensitive matching (handles "Edelmetalen" = "edelmetalen")
-        # IMPORTANT: project_id must be first param for the LEFT JOIN ta.project_id = ? above
+        # 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} %"
+            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

modules/keyboard_shortcuts_widget.py

@@ -301,6 +301,10 @@ class KeyboardShortcutsWidget(QWidget):
     
     def load_shortcuts(self):
         """Load shortcuts into the table"""
+        # CRITICAL: Disable sorting during table modifications to prevent
+        # items from becoming disassociated from their rows (causes vanishing text bug)
+        self.table.setSortingEnabled(False)
+        
         self.table.setRowCount(0)
         
         all_shortcuts = self.manager.get_all_shortcuts()
@@ -362,6 +366,9 @@ class KeyboardShortcutsWidget(QWidget):
                 self.table.setItem(row, 4, status_item)
                 
                 row += 1
+        
+        # Re-enable sorting after all modifications are complete
+        self.table.setSortingEnabled(True)
     
     def _on_enabled_changed(self, state):
         """Handle checkbox state change for enabling/disabling shortcuts"""

modules/non_translatables_manager.py

@@ -172,7 +172,7 @@ class NonTranslatablesManager:
         Initialize manager.
         
         Args:
-            base_path: Base path for NT files (typically user_data/Translation_Resources/Non-translatables)
+            base_path: Base path for NT files (typically user_data/resources/non_translatables)
             log_callback: Optional logging function
         """
         self.base_path = Path(base_path)

modules/prompt_library_migration.py

@@ -29,7 +29,7 @@ class PromptLibraryMigration:
     def __init__(self, prompt_library_dir: str, log_callback=None):
         """
         Args:
-            prompt_library_dir: Path to user_data/Prompt_Library
+            prompt_library_dir: Path to user_data/prompt_library
             log_callback: Function for logging
         """
         self.prompt_library_dir = Path(prompt_library_dir)

modules/setup_wizard.py

@@ -80,17 +80,17 @@ class SetupWizard:
                 "Supervertaler will create the following structure:\n\n"
                 f"{self.selected_path}\n"
                 f"  ├── api_keys.txt\n"
-                f"  ├── Prompt_Library/\n"
+                f"  ├── prompt_library/\n"
                 f"  │   ├── 1_System_Prompts/\n"
                 f"  │   ├── 2_Domain_Prompts/\n"
                 f"  │   ├── 3_Project_Prompts/\n"
                 f"  │   └── 4_Style_Guides/\n"
-                f"  ├── Translation_Resources/\n"
+                f"  ├── resources/\n"
                 f"  │   ├── TMs/\n"
                 f"  │   ├── Glossaries/\n"
-                f"  │   ├── Non-translatables/\n"
-                f"  │   └── Segmentation_rules/\n"
-                f"  └── Projects/\n\n"
+                f"  │   ├── non_translatables/\n"
+                f"  │   └── segmentation_rules/\n"
+                f"  └── projects/\n\n"
                 "Is this correct?"
             )
             
@@ -140,9 +140,9 @@ class SetupWizard:
                 f"Your data folder: {self.selected_path}\n\n"
                 f"Created:\n"
                 f"  • api_keys.txt (add your API keys here)\n"
-                f"  • Prompt_Library/ (your prompts)\n"
-                f"  • Translation_Resources/ (TMs, glossaries)\n"
-                f"  • Projects/ (your work)\n\n"
+                f"  • prompt_library/ (your prompts)\n"
+                f"  • resources/ (TMs, glossaries)\n"
+                f"  • projects/ (your work)\n\n"
                 f"All your translation memories, prompts, and projects\n"
                 f"will be stored in this location."
             )