GameSentenceMiner 2.7.17__py3-none-any.whl → 2.8.1__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -7,16 +7,15 @@ import urllib.request
 from datetime import datetime, timedelta
 from requests import post
 
-from GameSentenceMiner import obs, util, notification, ffmpeg, gametext
+from GameSentenceMiner import obs, util, notification, ffmpeg
 from GameSentenceMiner.ai.gemini import translate_with_context
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.configuration import get_config
-from GameSentenceMiner.gametext import get_text_event, get_all_lines
 from GameSentenceMiner.model import AnkiCard
-from GameSentenceMiner.utility_gui import get_utility_window
+from GameSentenceMiner.text_log import get_all_lines, get_text_event, get_mined_line
 from GameSentenceMiner.obs import get_current_game
 from GameSentenceMiner.util import remove_html_and_cloze_tags, combine_dialogue
-
+from GameSentenceMiner.web import texthooking_page
 
 audio_in_anki = None
 screenshot_in_anki = None
@@ -171,7 +170,7 @@ def get_initial_card_info(last_note: AnkiCard, selected_lines):
             last_note.get_field(get_config().anki.previous_sentence_field):
         logger.debug(
             f"Adding Previous Sentence: {get_config().anki.previous_sentence_field and game_line.prev.text and not last_note.get_field(get_config().anki.previous_sentence_field)}")
-        if selected_lines:
+        if selected_lines and selected_lines[0].prev:
             note['fields'][get_config().anki.previous_sentence_field] = selected_lines[0].prev.text
         else:
             note['fields'][get_config().anki.previous_sentence_field] = game_line.prev.text
@@ -277,10 +276,10 @@ def update_new_card():
     if get_config().obs.get_game_from_scene:
         obs.update_current_game()
     if use_prev_audio:
-        lines = get_utility_window().get_selected_lines()
+        lines = texthooking_page.get_selected_lines()
         with util.lock:
-            update_anki_card(last_card, note=get_initial_card_info(last_card, lines), game_line=gametext.get_mined_line(last_card, lines), reuse_audio=True)
-        get_utility_window().reset_checkboxes()
+            update_anki_card(last_card, note=get_initial_card_info(last_card, lines), game_line=get_mined_line(last_card, lines), reuse_audio=True)
+        texthooking_page.reset_checked_lines()
     else:
         logger.info("New card(s) detected! Added to Processing Queue!")
         card_queue.append(last_card)

GameSentenceMiner/config_gui.py

@@ -110,7 +110,8 @@ class ConfigApp:
                 websocket_uri=self.websocket_uri.get(),
                 open_config_on_startup=self.open_config_on_startup.get(),
                 open_multimine_on_startup=self.open_multimine_on_startup.get(),
-                texthook_replacement_regex=self.texthook_replacement_regex.get()
+                texthook_replacement_regex=self.texthook_replacement_regex.get(),
+                use_both_clipboard_and_websocket=self.use_both_clipboard_and_websocket.get()
             ),
             paths=Paths(
                 folder_to_watch=self.folder_to_watch.get(),
@@ -308,6 +309,13 @@ class ConfigApp:
         self.add_label_and_increment_row(general_frame, "Enable to allow GSM to see clipboard for text and line timing.",
                                          row=self.current_row, column=2)
 
+        ttk.Label(general_frame, text="Allow Both:").grid(row=self.current_row, column=0, sticky='W')
+        self.use_both_clipboard_and_websocket = tk.BooleanVar(value=self.settings.general.use_both_clipboard_and_websocket)
+        ttk.Checkbutton(general_frame, variable=self.use_both_clipboard_and_websocket).grid(row=self.current_row, column=1,
+                                                                                            sticky='W')
+        self.add_label_and_increment_row(general_frame, "Enable to allow GSM to accept both clipboard and websocket input at the same time.",
+                                            row=self.current_row, column=2)
+
         ttk.Label(general_frame, text="Websocket URI:").grid(row=self.current_row, column=0, sticky='W')
         self.websocket_uri = ttk.Entry(general_frame)
         self.websocket_uri.insert(0, self.settings.general.websocket_uri)
@@ -329,13 +337,21 @@ class ConfigApp:
         self.add_label_and_increment_row(general_frame, "Whether to open config when the script starts.",
                                          row=self.current_row, column=2)
 
-        ttk.Label(general_frame, text="Open Multimine on Startup:").grid(row=self.current_row, column=0, sticky='W')
+        ttk.Label(general_frame, text="Open GSM Texthooker on Startup:").grid(row=self.current_row, column=0, sticky='W')
         self.open_multimine_on_startup = tk.BooleanVar(value=self.settings.general.open_multimine_on_startup)
         ttk.Checkbutton(general_frame, variable=self.open_multimine_on_startup).grid(row=self.current_row, column=1,
                                                                                   sticky='W')
-        self.add_label_and_increment_row(general_frame, "Whether to open multimining window when the script starts.",
+        self.add_label_and_increment_row(general_frame, "Whether to open Texthooking page when the script starts.",
                                          row=self.current_row, column=2)
 
+        ttk.Label(general_frame, text="GSM Texthooker Port:").grid(row=self.current_row, column=0, sticky='W')
+        self.texthooker_port = ttk.Entry(general_frame)
+        self.texthooker_port.insert(0, str(self.settings.general.texthooker_port))
+        self.texthooker_port.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(general_frame, "Port for the Texthooker to run on. Only change if you know what you are doing", row=self.current_row,
+                                            column=2)
+
+
         ttk.Label(general_frame, text="Current Version:").grid(row=self.current_row, column=0, sticky='W')
         self.current_version = ttk.Label(general_frame, text=get_current_version())
         self.current_version.grid(row=self.current_row, column=1)

GameSentenceMiner/configuration.py

@@ -2,6 +2,7 @@ import json
 import logging
 import os
 import shutil
+import socket
 from dataclasses import dataclass, field
 from logging.handlers import RotatingFileHandler
 from os.path import expanduser
@@ -36,16 +37,17 @@ DEFAULT_CONFIG = 'Default'
 
 current_game = ''
 
-
 @dataclass_json
 @dataclass
 class General:
     use_websocket: bool = True
     use_clipboard: bool = True
+    use_both_clipboard_and_websocket: bool = False
     websocket_uri: str = 'localhost:6677'
     open_config_on_startup: bool = False
     open_multimine_on_startup: bool = False
     texthook_replacement_regex: str = ""
+    texthooker_port: int = 55000
 
 
 @dataclass_json
@@ -344,11 +346,16 @@ class Config:
             self.sync_shared_field(config.general, profile.general, "open_config_on_startup")
             self.sync_shared_field(config.general, profile.general, "open_multimine_on_startup")
             self.sync_shared_field(config.general, profile.general, "websocket_uri")
+            self.sync_shared_field(config.general, profile.general, "texthooker_port")
             self.sync_shared_field(config.audio, profile.audio, "external_tool")
             self.sync_shared_field(config.audio, profile.audio, "anki_media_collection")
             self.sync_shared_field(config, profile, "advanced")
             self.sync_shared_field(config, profile, "paths")
             self.sync_shared_field(config, profile, "obs")
+            self.sync_shared_field(config.ai, profile.ai, "anki_field")
+            self.sync_shared_field(config.ai, profile.ai, "provider")
+            self.sync_shared_field(config.ai, profile.ai, "api_key")
+
 
         return self
 

GameSentenceMiner/downloader/oneocr_dl.py

@@ -0,0 +1,243 @@
+import os
+import zipfile
+import shutil
+from os.path import expanduser
+
+import requests
+import re
+import tempfile
+
+# Placeholder functions/constants for removed proprietary ones
+# In a real application, you would replace these with appropriate logic
+# or standard library equivalents.
+
+def checkdir(d):
+    """Checks if a directory exists and contains the expected files."""
+    flist = ["oneocr.dll", "oneocr.onemodel", "onnxruntime.dll"]
+    return os.path.isdir(d) and all((os.path.isfile(os.path.join(d, _)) for _ in flist))
+
+def selectdir():
+    """Attempts to find the SnippingTool directory, prioritizing cache."""
+    cachedir = "cache/SnippingTool"
+    packageFamilyName = "Microsoft.ScreenSketch_8wekyb3d8bbwe"
+
+    if checkdir(cachedir):
+        return cachedir
+    # This part needs NativeUtils.GetPackagePathByPackageFamily, which is proprietary.
+    # We'll skip this part for simplification as requested.
+    # path = NativeUtils.GetPackagePathByPackageFamily(packageFamilyName)
+    # if not path:
+    #     return None
+    # path = os.path.join(path, "SnippingTool")
+    # if not checkdir(path):
+    #     return None
+    # return path
+    return None # Return None if not found in cache
+
+def getproxy():
+    """Placeholder for proxy retrieval."""
+    # Replace with actual proxy retrieval logic or return None
+    return None
+
+def stringfyerror(e):
+    """Placeholder for error stringification."""
+    return str(e)
+
+def dynamiclink(path):
+    """Placeholder for dynamic link resolution."""
+    # This would likely map a resource path to a local file path.
+    # For simplification, we'll just use the provided path string.
+    return path # Assuming path is a URL here based on usage
+
+# Simplified download logic extracted from the question class
+class Downloader:
+    def __init__(self):
+        self.oneocr_dir = expanduser("~/.config/oneocr")
+        self.packageFamilyName = "Microsoft.ScreenSketch_8wekyb3d8bbwe"
+        self.flist = ["oneocr.dll", "oneocr.onemodel", "onnxruntime.dll"]
+
+    def download_and_extract(self):
+        """
+        Main function to attempt download and extraction.
+        Tries official source first, then a fallback URL.
+        """
+        if checkdir(self.oneocr_dir):
+            print("Files already exist in cache.")
+            return True
+
+        try:
+            print("Attempting to download from official source...")
+            self.downloadofficial()
+            print("Download and extraction from official source successful.")
+            return True
+        except Exception as e:
+            print(f"Download from official source failed: {stringfyerror(e)}")
+            print("Attempting to download from fallback URL...")
+            try:
+                fallback_url = dynamiclink("/Resource/SnippingTool") # Assuming this resolves to a URL
+                self.downloadx(fallback_url)
+                print("Download and extraction from fallback URL successful.")
+                return True
+            except Exception as e_fallback:
+                print(f"Download from fallback URL failed: {stringfyerror(e_fallback)}")
+                print("All download attempts failed.")
+                return False
+
+
+    def downloadofficial(self):
+        """Downloads the latest SnippingTool MSIX bundle from a store API."""
+        headers = {
+            "accept": "*/*",
+            # Changed accept-language to prioritize US English
+            "accept-language": "en-US,en;q=0.9",
+            "cache-control": "no-cache",
+            "origin": "https://store.rg-adguard.net",
+            "pragma": "no-cache",
+            "priority": "u=1, i",
+            "referer": "https://store.rg-adguard.net/",
+            "sec-ch-ua": '"Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
+        }
+
+        data = dict(type="PackageFamilyName", url=self.packageFamilyName)
+
+        response = requests.post(
+            "https://store.rg-adguard.net/api/GetFiles",
+            headers=headers,
+            data=data,
+            proxies=getproxy(),
+        )
+        response.raise_for_status() # Raise an exception for bad status codes
+
+        saves = []
+        for link, package in re.findall('<a href="(.*?)".*?>(.*?)</a>', response.text):
+            if not package.startswith("Microsoft.ScreenSketch"):
+                continue
+            if not package.endswith(".msixbundle"):
+                continue
+            version = re.search(r"\d+\.\d+\.\d+\.\d+", package)
+            if not version:
+                continue
+            version = tuple(int(_) for _ in version.group().split("."))
+            saves.append((version, link, package))
+
+        if not saves:
+            raise Exception("Could not find suitable download link from official source.")
+
+        saves.sort(key=lambda _: _[0])
+        url = saves[-1][1]
+        package_name = saves[-1][2]
+
+        print(f"Downloading {package_name} from {url}")
+        req = requests.get(url, stream=True, proxies=getproxy())
+        req.raise_for_status()
+
+        total_size_in_bytes = int(req.headers.get('content-length', 0))
+        block_size = 1024 * 32 # 32 Kibibytes
+        temp_msixbundle_path = os.path.join(tempfile.gettempdir(), package_name)
+
+        with open(temp_msixbundle_path, "wb") as ff:
+            downloaded_size = 0
+            for chunk in req.iter_content(chunk_size=block_size):
+                ff.write(chunk)
+                downloaded_size += len(chunk)
+                # Basic progress reporting (can be removed)
+                if total_size_in_bytes:
+                    progress = (downloaded_size / total_size_in_bytes) * 100
+                    print(f"Downloaded {downloaded_size}/{total_size_in_bytes} bytes ({progress:.2f}%)", end='\r')
+        print("\nDownload complete. Extracting...")
+
+        namemsix = None
+        with zipfile.ZipFile(temp_msixbundle_path) as ff:
+            for name in ff.namelist():
+                if name.startswith("SnippingTool") and name.endswith("_x64.msix"):
+                    namemsix = name
+                    break
+            if not namemsix:
+                raise Exception("Could not find MSIX file within MSIXBUNDLE.")
+            temp_msix_path = os.path.join(tempfile.gettempdir(), namemsix)
+            ff.extract(namemsix, tempfile.gettempdir())
+
+        print(f"Extracted {namemsix}. Extracting components...")
+        if os.path.exists(self.oneocr_dir):
+             shutil.rmtree(self.oneocr_dir)
+        os.makedirs(self.oneocr_dir, exist_ok=True)
+
+        with zipfile.ZipFile(temp_msix_path) as ff:
+            collect = []
+            for name in ff.namelist():
+                # Extract only the files within the "SnippingTool/" directory
+                if name.startswith("SnippingTool/") and any(name.endswith(f) for f in self.flist):
+                     # Construct target path relative to cachedir
+                    target_path = os.path.join(self.oneocr_dir, os.path.relpath(name, "SnippingTool/"))
+                    # Ensure parent directories exist
+                    os.makedirs(os.path.dirname(target_path), exist_ok=True)
+                    # Extract the file
+                    with ff.open(name) as source, open(target_path, "wb") as target:
+                        shutil.copyfileobj(source, target)
+                    collect.append(name)
+            if not collect:
+                 raise Exception("Could not find required files within MSIX.")
+
+
+        if not checkdir(self.oneocr_dir):
+            raise Exception("Extraction failed: Required files not found in cache directory.")
+
+        # Clean up temporary files
+        os.remove(temp_msixbundle_path)
+        os.remove(temp_msix_path)
+
+
+    def downloadx(self, url: str):
+        """Downloads a zip file from a URL and extracts it."""
+        print(f"Downloading from fallback URL: {url}")
+        # Added accept-language to the fallback download as well for consistency
+        headers = {
+             "accept-language": "en-US,en;q=0.9",
+             # Add other relevant headers if necessary for the fallback URL
+             "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
+             "accept": "*/*",
+        }
+        req = requests.get(url, verify=False, proxies=getproxy(), stream=True, headers=headers)
+        req.raise_for_status()
+
+        total_size_in_bytes = int(req.headers.get('content-length', 0))
+        block_size = 1024 * 32 # 32 Kibibytes
+        temp_zip_path = os.path.join(tempfile.gettempdir(), url.split("/")[-1])
+
+        with open(temp_zip_path, "wb") as ff:
+            downloaded_size = 0
+            for chunk in req.iter_content(chunk_size=block_size):
+                ff.write(chunk)
+                downloaded_size += len(chunk)
+                 # Basic progress reporting (can be removed)
+                if total_size_in_bytes:
+                    progress = (downloaded_size / total_size_in_bytes) * 100
+                    print(f"Downloaded {downloaded_size}/{total_size_in_bytes} bytes ({progress:.2f}%)", end='\r')
+        print("\nDownload complete. Extracting...")
+
+        if os.path.exists(self.oneocr_dir):
+             shutil.rmtree(self.oneocr_dir)
+        os.makedirs(self.oneocr_dir, exist_ok=True)
+
+        with zipfile.ZipFile(temp_zip_path) as zipf:
+            zipf.extractall(self.oneocr_dir)
+
+        if not checkdir(self.oneocr_dir):
+            raise Exception("Extraction failed: Required files not found in cache directory.")
+
+        # Clean up temporary files
+        os.remove(temp_zip_path)
+
+# Example usage:
+if __name__ == "__main__":
+    downloader = Downloader()
+    if downloader.download_and_extract():
+        print("SnippingTool files are ready.")
+    else:
+        print("Failed to obtain SnippingTool files.")

GameSentenceMiner/ffmpeg.py

@@ -1,11 +1,9 @@
-import subprocess
 import tempfile
-import time
 
 from GameSentenceMiner import obs, util, configuration
 from GameSentenceMiner.configuration import *
+from GameSentenceMiner.text_log import initial_time
 from GameSentenceMiner.util import *
-from GameSentenceMiner.gametext import initial_time
 
 
 def get_ffmpeg_path():

GameSentenceMiner/gametext.py

@@ -1,24 +1,19 @@
 import asyncio
-import difflib
 import re
 import threading
 import time
-from datetime import datetime, timedelta
 
 import pyperclip
 import websockets
 from websockets import InvalidStatus
 
 from GameSentenceMiner import util
-from GameSentenceMiner.model import AnkiCard
 from GameSentenceMiner.configuration import *
-from GameSentenceMiner.configuration import get_config, logger
-from GameSentenceMiner.util import remove_html_and_cloze_tags
-from difflib import SequenceMatcher
+from GameSentenceMiner.text_log import *
+from GameSentenceMiner.util import do_text_replacements, TEXT_REPLACEMENTS_FILE
 
-from GameSentenceMiner.utility_gui import get_utility_window
+from GameSentenceMiner.web.texthooking_page import add_event_to_texthooker
 
-initial_time = datetime.now()
 current_line = ''
 current_line_after_regex = ''
 current_line_time = datetime.now()
@@ -26,72 +21,9 @@ current_line_time = datetime.now()
 reconnecting = False
 websocket_connected = False
 
-@dataclass
-class GameLine:
-    text: str
-    time: datetime
-    prev: 'GameLine'
-    next: 'GameLine'
-    index: int = 0
-
-    def get_previous_time(self):
-        if self.prev:
-            return self.prev.time
-        return initial_time
-
-    def get_next_time(self):
-        if self.next:
-            return self.next.time
-        return 0
-
-    def __str__(self):
-        return str({"text": self.text, "time": self.time})
-
-@dataclass
-class GameText:
-    values: list[GameLine]
-    game_line_index = 0
-
-    def __init__(self):
-        self.values = []
-
-    def __getitem__(self, key):
-        return self.values[key]
-
-    def get_time(self, line_text: str, occurrence: int = -1) -> datetime:
-        matches = [line for line in self.values if line.text == line_text]
-        if matches:
-            return matches[occurrence].time  # Default to latest
-        return initial_time
-
-    def get_event(self, line_text: str, occurrence: int = -1) -> GameLine | None:
-        matches = [line for line in self.values if line.text == line_text]
-        if matches:
-            return matches[occurrence]
-        return None
-
-    def add_line(self, line_text, line_time=None):
-        if not line_text:
-            return
-        new_line = GameLine(line_text, line_time if line_time else datetime.now(), self.values[-1] if self.values else None, None, self.game_line_index)
-        logger.debug(f"Adding line: {new_line}")
-        self.game_line_index += 1
-        if self.values:
-            self.values[-1].next = new_line
-        self.values.append(new_line)
-        # self.remove_old_events(datetime.now() - timedelta(minutes=10))
-
-    def has_line(self, line_text) -> bool:
-        for game_line in self.values:
-            if game_line.text == line_text:
-                return True
-        return False
-
     # def remove_old_events(self, cutoff_time: datetime):
     #     self.values = [line for line in self.values if line.time >= cutoff_time]
 
-line_history = GameText()
-
 class ClipboardMonitor(threading.Thread):
 
     def __init__(self):
@@ -99,14 +31,14 @@ class ClipboardMonitor(threading.Thread):
         self.daemon = True
 
     def run(self):
-        global current_line_time, current_line, line_history
+        global current_line_time, current_line
 
         # Initial clipboard content
         current_line = pyperclip.paste()
 
         skip_next_clipboard = False
         while True:
-            if websocket_connected:
+            if not get_config().general.use_both_clipboard_and_websocket and websocket_connected:
                 time.sleep(1)
                 skip_next_clipboard = True
                 continue
@@ -120,7 +52,7 @@ class ClipboardMonitor(threading.Thread):
 
 
 async def listen_websocket():
-    global current_line, current_line_time, line_history, reconnecting, websocket_connected
+    global current_line, current_line_time, reconnecting, websocket_connected
     try_other = False
     websocket_url = f'ws://{get_config().general.websocket_uri}/gsm'
     while True:
@@ -130,7 +62,7 @@ async def listen_websocket():
             async with websockets.connect(websocket_url, ping_interval=None) as websocket:
                 logger.info("TextHooker Websocket Connected!")
                 if reconnecting:
-                    logger.info(f"Texthooker WebSocket connected Successfully!" + " Disabling Clipboard Monitor." if get_config().general.use_clipboard else "")
+                    logger.info(f"Texthooker WebSocket connected Successfully!" + " Disabling Clipboard Monitor." if (get_config().general.use_clipboard and not get_config().general.use_both_clipboard_and_websocket) else "")
                     reconnecting = False
                 websocket_connected = True
                 try_other = True
@@ -164,18 +96,17 @@ async def listen_websocket():
             await asyncio.sleep(5)
 
 def handle_new_text_event(current_clipboard, line_time=None):
-    global current_line, current_line_time, line_history, current_line_after_regex
+    global current_line, current_line_time, current_line_after_regex
     current_line = current_clipboard
     if get_config().general.texthook_replacement_regex:
         current_line_after_regex = re.sub(get_config().general.texthook_replacement_regex, '', current_line)
     else:
         current_line_after_regex = current_line
+    current_line_after_regex = do_text_replacements(current_line, TEXT_REPLACEMENTS_FILE)
     logger.info(f"Line Received: {current_line_after_regex}")
     current_line_time = line_time if line_time else datetime.now()
-    line_history.add_line(current_line_after_regex, line_time)
-    if get_utility_window():
-        get_utility_window().add_text(line_history[-1])
-
+    add_line(current_line_after_regex, line_time)
+    add_event_to_texthooker(get_text_log()[-1])
 
 def reset_line_hotkey_pressed():
     global current_line_time
@@ -193,78 +124,8 @@ def start_text_monitor():
         threading.Thread(target=run_websocket_listener, daemon=True).start()
     if get_config().general.use_clipboard:
         if get_config().general.use_websocket:
-            logger.info("Both WebSocket and Clipboard monitoring are enabled. WebSocket will take precedence if connected.")
-        ClipboardMonitor().start()
-
-
-def similar(a, b):
-    return SequenceMatcher(None, a, b).ratio()
-
-def one_contains_the_other(a, b):
-    return a in b or b in a
-
-def lines_match(a, b):
-    similarity = similar(a, b)
-    logger.debug(f"Comparing: {a} with {b} - Similarity: {similarity}, Or One contains the other: {one_contains_the_other(a, b)}")
-    return similar(a, b) >= 0.60 or one_contains_the_other(a, b)
-
-def get_text_event(last_note) -> GameLine:
-    lines = line_history.values
-
-    if not lines:
-        raise Exception("No lines in history. Text is required from either clipboard or websocket for GSM to work. Please check your setup/config.")
-
-    if not last_note:
-        return lines[-1]
-
-    sentence = last_note.get_field(get_config().anki.sentence_field)
-    if not sentence:
-        return lines[-1]
-
-    for line in reversed(lines):
-        if lines_match(line.text, remove_html_and_cloze_tags(sentence)):
-            return line
-
-    logger.debug("Couldn't find a match in history, using last event")
-    return lines[-1]
-
-
-def get_line_and_future_lines(last_note):
-    if not last_note:
-        return []
-
-    sentence = last_note.get_field(get_config().anki.sentence_field)
-    found_lines = []
-    if sentence:
-        found = False
-        for line in line_history.values:
-            if found:
-                found_lines.append(line.text)
-            if lines_match(line.text, remove_html_and_cloze_tags(sentence)):  # 80% similarity threshold
-                found = True
-                found_lines.append(line.text)
-    return found_lines
-
-def get_mined_line(last_note: AnkiCard, lines):
-    if not last_note:
-        return lines[-1]
-    if not lines:
-        lines = get_all_lines()
-
-    sentence = last_note.get_field(get_config().anki.sentence_field)
-    for line in lines:
-        if lines_match(line.text, remove_html_and_cloze_tags(sentence)):
-            return line
-    return lines[-1]
-
-
-def get_time_of_line(line):
-    return line_history.get_time(line)
-
-
-def get_all_lines():
-    return line_history.values
-
-
-def get_line_history():
-    return line_history
+            if get_config().general.use_both_clipboard_and_websocket:
+                logger.info("Listening for Text on both WebSocket and Clipboard.")
+            else:
+                logger.info("Both WebSocket and Clipboard monitoring are enabled. WebSocket will take precedence if connected.")
+        ClipboardMonitor().start()