supervertaler 1.9.181__py3-none-any.whl → 1.9.183__py3-none-any.whl

modules/project_tm.py

@@ -0,0 +1,320 @@
+"""
+ProjectTM - In-memory TM for instant grid lookups (Total Recall architecture)
+
+This module implements a lightweight in-memory Translation Memory that extracts
+relevant segments from the full TM database on project load. This makes grid
+navigation instant while keeping the full TM for concordance searches.
+
+Inspired by CafeTran's "Total Recall" feature.
+"""
+
+import sqlite3
+import threading
+from difflib import SequenceMatcher
+from typing import Dict, List, Optional, Callable
+import re
+
+
+class ProjectTM:
+    """
+    Lightweight in-memory TM extracted from the main TM database.
+
+    On project load, extracts segments that are relevant to the current project
+    (fuzzy matches above threshold) into an in-memory SQLite database for
+    instant lookups during grid navigation.
+
+    Usage:
+        project_tm = ProjectTM()
+        project_tm.extract_from_database(
+            db_manager,
+            project_segments,
+            tm_ids=['tm1', 'tm2'],
+            threshold=0.75,
+            progress_callback=lambda cur, total: print(f"{cur}/{total}")
+        )
+
+        # Fast lookup during grid navigation
+        matches = project_tm.search("source text to translate")
+    """
+
+    def __init__(self):
+        """Initialize in-memory SQLite database for ProjectTM"""
+        self.conn = sqlite3.connect(":memory:", check_same_thread=False)
+        self.conn.row_factory = sqlite3.Row
+        self.lock = threading.Lock()
+        self.is_built = False
+        self.segment_count = 0
+
+        # Create the schema
+        self._create_schema()
+
+    def _create_schema(self):
+        """Create the in-memory database schema"""
+        with self.lock:
+            cursor = self.conn.cursor()
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS segments (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    source_text TEXT NOT NULL,
+                    target_text TEXT NOT NULL,
+                    source_lower TEXT NOT NULL,
+                    tm_id TEXT,
+                    tm_name TEXT,
+                    similarity REAL,
+                    original_id INTEGER
+                )
+            """)
+            # Index for fast exact match lookups
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_source_lower ON segments(source_lower)")
+            # FTS5 for fuzzy text search
+            cursor.execute("""
+                CREATE VIRTUAL TABLE IF NOT EXISTS segments_fts USING fts5(
+                    source_text,
+                    content=segments,
+                    content_rowid=id
+                )
+            """)
+            self.conn.commit()
+
+    def clear(self):
+        """Clear all segments from the ProjectTM"""
+        with self.lock:
+            cursor = self.conn.cursor()
+            cursor.execute("DELETE FROM segments")
+            cursor.execute("DELETE FROM segments_fts")
+            self.conn.commit()
+            self.is_built = False
+            self.segment_count = 0
+
+    def extract_from_database(
+        self,
+        db_manager,
+        project_segments: List,
+        tm_ids: List[str] = None,
+        source_lang: str = None,
+        target_lang: str = None,
+        threshold: float = 0.75,
+        progress_callback: Optional[Callable[[int, int], None]] = None,
+        log_callback: Optional[Callable[[str], None]] = None
+    ) -> int:
+        """
+        Extract relevant segments from the main TM database into ProjectTM.
+
+        For each unique source text in the project, searches the TM for fuzzy
+        matches above the threshold and stores them in memory.
+
+        Args:
+            db_manager: The main database manager with TM data
+            project_segments: List of project segments to find matches for
+            tm_ids: List of TM IDs to search (None = all active TMs)
+            source_lang: Source language filter
+            target_lang: Target language filter
+            threshold: Minimum similarity threshold (0.0-1.0)
+            progress_callback: Optional callback(current, total) for progress
+            log_callback: Optional callback(message) for logging
+
+        Returns:
+            Number of TM segments extracted
+        """
+        def log(msg):
+            if log_callback:
+                log_callback(msg)
+            else:
+                print(msg)
+
+        self.clear()
+
+        if not project_segments or not db_manager:
+            log(f"[ProjectTM] Early exit: segments={bool(project_segments)}, db={bool(db_manager)}")
+            return 0
+
+        # Get unique source texts from project
+        unique_sources = {}
+        for seg in project_segments:
+            # Try both 'source' and 'source_text' attributes (different segment types use different names)
+            source = getattr(seg, 'source', None) or getattr(seg, 'source_text', None)
+            if source and source.strip():
+                # Normalize: strip and lowercase for deduplication
+                key = source.strip().lower()
+                if key not in unique_sources:
+                    unique_sources[key] = source.strip()
+
+        total = len(unique_sources)
+        log(f"[ProjectTM] Found {total} unique source texts from {len(project_segments)} segments")
+        if total == 0:
+            return 0
+
+        extracted_count = 0
+        seen_sources = set()  # Deduplicate TM entries
+
+        cursor = self.conn.cursor()
+
+        log(f"[ProjectTM] Searching TMs: {tm_ids}, threshold={threshold}, langs={source_lang}->{target_lang}")
+
+        for i, (key, source_text) in enumerate(unique_sources.items()):
+            if progress_callback and i % 10 == 0:
+                progress_callback(i, total)
+
+            try:
+                # Search main TM database for fuzzy matches
+                matches = db_manager.search_fuzzy_matches(
+                    source_text,
+                    tm_ids=tm_ids,
+                    threshold=threshold,
+                    max_results=10,  # Keep top 10 matches per source
+                    source_lang=source_lang,
+                    target_lang=target_lang,
+                    bidirectional=True
+                )
+
+                # Debug: log first search
+                if i == 0:
+                    log(f"[ProjectTM] First search '{source_text[:50]}...' returned {len(matches)} matches")
+
+                for match in matches:
+                    match_source = match.get('source_text', '')
+                    match_target = match.get('target_text', '')
+
+                    if not match_source or not match_target:
+                        continue
+
+                    # Deduplicate by source text
+                    source_key = match_source.strip().lower()
+                    if source_key in seen_sources:
+                        continue
+                    seen_sources.add(source_key)
+
+                    # Insert into ProjectTM
+                    cursor.execute("""
+                        INSERT INTO segments (source_text, target_text, source_lower,
+                                            tm_id, tm_name, similarity, original_id)
+                        VALUES (?, ?, ?, ?, ?, ?, ?)
+                    """, (
+                        match_source,
+                        match_target,
+                        source_key,
+                        match.get('tm_id'),
+                        match.get('tm_name', 'Unknown TM'),
+                        match.get('similarity', 0),
+                        match.get('id')
+                    ))
+                    extracted_count += 1
+
+            except Exception as e:
+                # Log but continue - don't fail extraction for one bad segment
+                pass
+
+        # Commit all inserts
+        self.conn.commit()
+
+        # Rebuild FTS5 index
+        try:
+            cursor.execute("INSERT INTO segments_fts(segments_fts) VALUES('rebuild')")
+            self.conn.commit()
+        except Exception:
+            pass  # FTS rebuild may fail if no data, that's OK
+
+        if progress_callback:
+            progress_callback(total, total)
+
+        self.is_built = True
+        self.segment_count = extracted_count
+
+        return extracted_count
+
+    def search(self, source_text: str, max_results: int = 5) -> List[Dict]:
+        """
+        Search ProjectTM for matches (instant lookup).
+
+        First checks for exact matches, then falls back to fuzzy search.
+
+        Args:
+            source_text: Source text to search for
+            max_results: Maximum number of results to return
+
+        Returns:
+            List of match dictionaries with source_text, target_text, similarity, etc.
+        """
+        if not self.is_built or not source_text:
+            return []
+
+        source_lower = source_text.strip().lower()
+        results = []
+
+        with self.lock:
+            cursor = self.conn.cursor()
+
+            # 1. Check for exact match first (fastest)
+            cursor.execute("""
+                SELECT * FROM segments WHERE source_lower = ? LIMIT 1
+            """, (source_lower,))
+            exact = cursor.fetchone()
+
+            if exact:
+                results.append({
+                    'source_text': exact['source_text'],
+                    'target_text': exact['target_text'],
+                    'tm_id': exact['tm_id'],
+                    'tm_name': exact['tm_name'],
+                    'similarity': 1.0,  # Exact match
+                    'match_pct': 100,
+                    'id': exact['original_id']
+                })
+                return results  # Exact match - no need to search further
+
+            # 2. FTS5 fuzzy search
+            try:
+                # Tokenize query for FTS5
+                clean_text = re.sub(r'[^\w\s]', ' ', source_text)
+                search_terms = [t for t in clean_text.split() if len(t) > 2]
+
+                if search_terms:
+                    fts_query = ' OR '.join(f'"{term}"' for term in search_terms[:10])
+
+                    cursor.execute("""
+                        SELECT s.*, bm25(segments_fts) as rank
+                        FROM segments s
+                        JOIN segments_fts ON s.id = segments_fts.rowid
+                        WHERE segments_fts MATCH ?
+                        ORDER BY rank
+                        LIMIT ?
+                    """, (fts_query, max_results * 3))  # Get more candidates for re-ranking
+
+                    candidates = cursor.fetchall()
+
+                    # Re-rank by actual similarity
+                    for row in candidates:
+                        similarity = self._calculate_similarity(source_text, row['source_text'])
+                        if similarity >= 0.5:  # Lower threshold for ProjectTM (pre-filtered)
+                            results.append({
+                                'source_text': row['source_text'],
+                                'target_text': row['target_text'],
+                                'tm_id': row['tm_id'],
+                                'tm_name': row['tm_name'],
+                                'similarity': similarity,
+                                'match_pct': int(similarity * 100),
+                                'id': row['original_id']
+                            })
+
+                    # Sort by similarity and limit
+                    results.sort(key=lambda x: x['similarity'], reverse=True)
+                    results = results[:max_results]
+
+            except Exception:
+                pass  # FTS search may fail, return what we have
+
+        return results
+
+    def _calculate_similarity(self, text1: str, text2: str) -> float:
+        """Calculate similarity ratio between two texts"""
+        # Strip HTML/XML tags for comparison
+        clean1 = re.sub(r'<[^>]+>', '', text1).lower()
+        clean2 = re.sub(r'<[^>]+>', '', text2).lower()
+        return SequenceMatcher(None, clean1, clean2).ratio()
+
+    def get_stats(self) -> Dict:
+        """Get statistics about the ProjectTM"""
+        return {
+            'is_built': self.is_built,
+            'segment_count': self.segment_count
+        }

modules/termbase_manager.py

@@ -609,7 +609,6 @@ class TermbaseManager:
             """, (project_id,))
             
             active_ids = [row[0] for row in cursor.fetchall()]
-            self.log(f"📋 Found {len(active_ids)} active termbases for project {project_id}: {active_ids}")
             return active_ids
         except Exception as e:
             self.log(f"✗ Error getting active termbase IDs: {e}")

modules/termview_widget.py

@@ -734,15 +734,9 @@ class TermviewWidget(QWidget):
         has_termbase = termbase_matches and len(termbase_matches) > 0
         has_nt = nt_matches and len(nt_matches) > 0
 
-        if not has_termbase and not has_nt:
-            # Show appropriate message based on status hint
-            if status_hint == 'no_termbases_activated':
-                self.info_label.setText("No glossaries activated. Go to Resources → Glossary to activate.")
-            elif status_hint == 'wrong_language':
-                self.info_label.setText("Activated glossaries don't match project language pair.")
-            else:
-                self.info_label.setText("No terminology or NT matches for this segment")
-            return
+        # Store status hint for info label (will be set at the end)
+        self._status_hint = status_hint
+        self._has_any_matches = has_termbase or has_nt
         
         # Convert termbase matches to dict for easy lookup: {source_term.lower(): [translations]}
         matches_dict = {}
@@ -874,11 +868,18 @@ class TermviewWidget(QWidget):
             info_parts.append(f"{blocks_with_translations} terms")
         if blocks_with_nt > 0:
             info_parts.append(f"{blocks_with_nt} NTs")
-        
+
         if info_parts:
             self.info_label.setText(f"✓ Found {', '.join(info_parts)} in {len(tokens)} words")
         else:
-            self.info_label.setText(f"No matches in {len(tokens)} words")
+            # Show appropriate message based on status hint when no matches
+            status_hint = getattr(self, '_status_hint', None)
+            if status_hint == 'no_termbases_activated':
+                self.info_label.setText(f"No glossaries activated ({len(tokens)} words)")
+            elif status_hint == 'wrong_language':
+                self.info_label.setText(f"Glossaries don't match language pair ({len(tokens)} words)")
+            else:
+                self.info_label.setText(f"No matches in {len(tokens)} words")
     
     def get_all_termbase_matches(self, text: str) -> Dict[str, List[Dict]]:
         """

modules/translation_memory.py

@@ -205,20 +205,14 @@ class TMDatabase:
         Returns:
             List of match dictionaries sorted by similarity
         """
-        print(f"[DEBUG] TMDatabase.search_all: source='{source[:50]}...', tm_ids={tm_ids}")
-        
         # Determine which TMs to search
         # If tm_ids is None or empty, search ALL TMs (don't filter by tm_id)
         if tm_ids is None and enabled_only:
             tm_ids = [tm_id for tm_id, meta in self.tm_metadata.items() if meta.get('enabled', True)]
-            print(f"[DEBUG] TMDatabase.search_all: No tm_ids provided, using from metadata: {tm_ids}")
-        
+
         # If tm_ids is still empty, set to None to search ALL TMs
         if tm_ids is not None and len(tm_ids) == 0:
             tm_ids = None
-            print(f"[DEBUG] TMDatabase.search_all: Empty tm_ids, setting to None to search ALL")
-        
-        print(f"[DEBUG] TMDatabase.search_all: Final tm_ids to search: {tm_ids}")
         
         # First try exact match
         exact_match = self.db.get_exact_match(
@@ -227,8 +221,7 @@ class TMDatabase:
             source_lang=self.source_lang,
             target_lang=self.target_lang
         )
-        print(f"[DEBUG] TMDatabase.search_all: Exact match result: {exact_match}")
-        
+
         if exact_match:
             # Format as match dictionary
             return [{
@@ -241,7 +234,6 @@ class TMDatabase:
             }]
         
         # Try fuzzy matches
-        print(f"[DEBUG] TMDatabase.search_all: Calling fuzzy search with source_lang={self.source_lang}, target_lang={self.target_lang}")
         fuzzy_matches = self.db.search_fuzzy_matches(
             source=source,
             tm_ids=tm_ids,
@@ -250,8 +242,7 @@ class TMDatabase:
             source_lang=self.source_lang,
             target_lang=self.target_lang
         )
-        print(f"[DEBUG] TMDatabase.search_all: Fuzzy search returned {len(fuzzy_matches)} matches")
-        
+
         # Format matches for UI
         formatted_matches = []
         for match in fuzzy_matches:

modules/translation_results_panel.py

@@ -1676,13 +1676,6 @@ class TranslationResultsPanel(QWidget):
         Args:
             matches_dict: Dict with keys like "NT", "MT", "TM", "Termbases"
         """
-        print(f"🎯 TranslationResultsPanel.set_matches() called with matches_dict keys: {list(matches_dict.keys())}")
-        for match_type, matches in matches_dict.items():
-            print(f"  {match_type}: {len(matches)} matches")
-            if match_type == "Termbases" and matches:
-                for i, match in enumerate(matches[:2]):  # Show first 2 for debugging
-                    print(f"    [{i}] {match.source} → {match.target}")
-        
         # Ensure CompactMatchItem has current theme_manager
         if self.theme_manager:
             CompactMatchItem.theme_manager = self.theme_manager

{supervertaler-1.9.181.dist-info → supervertaler-1.9.183.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supervertaler
-Version: 1.9.181
+Version: 1.9.183
 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.181.dist-info → supervertaler-1.9.183.dist-info}/RECORD

@@ -1,4 +1,4 @@
-Supervertaler.py,sha256=8dvcmMQ-U7MpzzXQVLAsoB0O-yF_HMl142HfIiaMprE,2333467
+Supervertaler.py,sha256=8_tSjEorQseT5osmoDfk6WoeoCOmtfPhFjQcwRPsQfk,2338474
 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
@@ -14,6 +14,7 @@ modules/docx_handler.py,sha256=jSlZs5tollJnsnIA80buEXLfZBunp_GQ9lCtFZPUnBs,34053
 modules/encoding_repair.py,sha256=mrQSOMW-tvaowLja_gtXDJv3Qw4YhLCLsuZtBS0BVms,11900
 modules/encoding_repair_Qt.py,sha256=UosUOpMnXf0gkgp_F_4wszd25Op_3X_4h9kWMomK0Sk,17533
 modules/encoding_repair_ui.py,sha256=bRnyFg-5_Lz-bZoNT5eivM5LKsQgpoxbllsffYW3fAg,18619
+modules/extract_tm.py,sha256=ix58ti1_Zkd2dxIx1PwN8rWxmYHGv2zsUPrT-VfcMwA,18228
 modules/feature_manager.py,sha256=toQnOjeCPMTWp3sas-J88-ZAomFdoeRLKPc19C-6XFo,12416
 modules/figure_context_manager.py,sha256=hy7h5PcvN8qr8nQtDS41YvTwr6gecWvmjzMBP43_LM8,12682
 modules/file_dialog_helper.py,sha256=0dthKAFBkoQkdGm_zsYQMImn31Z9Bc9-VKNV5idZtkQ,3767
@@ -34,6 +35,7 @@ modules/pdf_rescue_Qt.py,sha256=9W_M0Zms4miapQbrqm-viHNCpaW39GL9VaKKFCJxpnE,8047
 modules/pdf_rescue_tkinter.py,sha256=a4R_OUnn7X5O_XMR1roybrdu1aXoGCwwO-mwYB2ZpOg,39606
 modules/phrase_docx_handler.py,sha256=7vJNbvxxURzdcinZ3rkqyJ-7Y5O1NpVL4Lvu9NuGFjQ,18598
 modules/project_home_panel.py,sha256=P0PgMnoPp6WEiGrfq8cNJNEdxO83aHQDdXzRLqF173w,6810
+modules/project_tm.py,sha256=TQUc9ApZjfiKZlA4bc1PrHwtEtk_XM9XArCd53De_20,12327
 modules/prompt_assistant.py,sha256=shkZqNTvyQKNDO_9aFEu1_gN0zQq0fR5krXkWfnTR2Y,13150
 modules/prompt_library.py,sha256=t5w4cqB6_Sin4BQDVNALKpfB1EN_oaDeHFwlHxILLSY,26894
 modules/prompt_library_migration.py,sha256=fv3RHhe2-EnH50XW5tyTWy0YP_KJ2EsESuTxR8klfmI,17639
@@ -58,8 +60,8 @@ modules/tag_manager.py,sha256=g66S0JSxdguN9AhWzZG3hsIz87Ul51wQ3c2wOCTZVSk,12789
 modules/term_extractor.py,sha256=qPvKNCVXFTGEGwXNvvC0cfCmdb5c3WhzE38EOgKdKUI,11253
 modules/termbase_entry_editor.py,sha256=iWO9CgLjMomGAqBXDsGAX7TFJvDOp2s_taS4gBL1rZY,35818
 modules/termbase_import_export.py,sha256=16IAY04IS_rgt0GH5UOUzUI5NoqAli4JMfMquxmFBm0,23552
-modules/termbase_manager.py,sha256=7KXEFab6y0o1EmFZwHs3ADklC95udVenxvrmN4XUoj0,48808
-modules/termview_widget.py,sha256=PibDY55CjBY4BSb6aMGEp4Y2JHNB67QWOQFTDNyeYy8,53968
+modules/termbase_manager.py,sha256=XAVrz-wt8jKcjoD6ocHoXewY5PN0A0GeqFEctsv0jS8,48697
+modules/termview_widget.py,sha256=zK0vYBJZpvD4flg-W5QAdCY6EGONjkWHYf-C_Kuofo0,54037
 modules/theme_manager.py,sha256=Qk_jfCmfm7fjdMAOyBHpD18w3MiRfWBZk0cHTw6yAAg,18639
 modules/tm_editor_dialog.py,sha256=AzGwq4QW641uFJdF8DljLTRRp4FLoYX3Pe4rlTjQWNg,3517
 modules/tm_manager_qt.py,sha256=h2bvXkRuboHf_RRz9-5FX35GVRlpXgRDWeXyj1QWtPs,54406
@@ -69,17 +71,17 @@ modules/tmx_editor_qt.py,sha256=PxBIUw_06PHYTBHsd8hZzVJXW8T0A0ljfz1Wjjsa4yU,1170
 modules/tmx_generator.py,sha256=pNkxwdMLvSRMMru0lkB1gvViIpg9BQy1EVhRbwoef3k,9426
 modules/tracked_changes.py,sha256=S_BIEC6r7wVAwjG42aSy_RgH4KaMAC8GS5thEvqrYdE,39480
 modules/trados_docx_handler.py,sha256=VPRAQ73cUHs_SEj6x81z1PmSxfjnwPBp9P4fXeK3KpQ,16363
-modules/translation_memory.py,sha256=13PDK4_kgYrWTACWBIBypOh2DvoxY9cRT8U6ulilbh4,28739
-modules/translation_results_panel.py,sha256=DmEe0pZRSfcZFg2cWeEREK7H9vrTcPkgeuMW54Pgrys,92505
+modules/translation_memory.py,sha256=LnG8csZNL2GTHXT4zk0uecJEtvRc-MKwv7Pt7EX3s7s,28002
+modules/translation_results_panel.py,sha256=OWqzV9xmJOi8NGCi3h42nq-qE7-v6WStjQWRsghCVbQ,92044
 modules/translation_services.py,sha256=lyVpWuZK1wtVtYZMDMdLoq1DHBoSaeAnp-Yejb0TlVQ,10530
 modules/unified_prompt_library.py,sha256=96u4WlMwnmmhD4uNJHZ-qVQj8v9_8dA2AVCWpBcwTrg,26006
 modules/unified_prompt_manager_qt.py,sha256=U89UFGG-M7BLetoaLAlma0x-n8SIyx682DhSvaRnzJs,171285
 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.181.dist-info/licenses/LICENSE,sha256=m28u-4qL5nXIWnJ6xlQVw__H30rWFtRK3pCOais2OuY,1092
-supervertaler-1.9.181.dist-info/METADATA,sha256=OQ1LAlPRGRyBLRAy3jX7II9VFMlrIMqy-s3o1L_NELg,5725
-supervertaler-1.9.181.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-supervertaler-1.9.181.dist-info/entry_points.txt,sha256=NP4hiCvx-_30YYKqgr-jfJYQvHr1qTYBMfoVmKIXSM8,53
-supervertaler-1.9.181.dist-info/top_level.txt,sha256=9tUHBYUSfaE4S2E4W3eavJsDyYymkwLfeWAHHAPT6Dk,22
-supervertaler-1.9.181.dist-info/RECORD,,
+supervertaler-1.9.183.dist-info/licenses/LICENSE,sha256=m28u-4qL5nXIWnJ6xlQVw__H30rWFtRK3pCOais2OuY,1092
+supervertaler-1.9.183.dist-info/METADATA,sha256=MoZSNxW6WqAUNIyvHTQ_2r6vC3Pl6e281sH7_WbePPk,5725
+supervertaler-1.9.183.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+supervertaler-1.9.183.dist-info/entry_points.txt,sha256=NP4hiCvx-_30YYKqgr-jfJYQvHr1qTYBMfoVmKIXSM8,53
+supervertaler-1.9.183.dist-info/top_level.txt,sha256=9tUHBYUSfaE4S2E4W3eavJsDyYymkwLfeWAHHAPT6Dk,22
+supervertaler-1.9.183.dist-info/RECORD,,