GameSentenceMiner 2.9.3__py3-none-any.whl → 2.9.5__py3-none-any.whl

GameSentenceMiner/vad.py

@@ -0,0 +1,344 @@
+import subprocess
+import tempfile
+import warnings
+from abc import abstractmethod, ABC
+
+from GameSentenceMiner.util import configuration, ffmpeg
+from GameSentenceMiner.util.configuration import *
+from GameSentenceMiner.util.ffmpeg import get_ffprobe_path
+
+
+def get_audio_length(path):
+    result = subprocess.run(
+        [get_ffprobe_path(), "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", path],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True
+    )
+    return float(result.stdout.strip())
+
+class VADResult:
+    def __init__(self, success: bool, start: float, end: float, model: str, output_audio: str = None):
+        self.success = success
+        self.start = start
+        self.end = end
+        self.model = model
+        self.output_audio = None
+
+    def __repr__(self):
+        return f"VADResult(success={self.success}, start={self.start}, end={self.end}, model={self.model}, output_audio={self.output_audio})"
+
+    def trim_successful_string(self):
+        if self.success:
+            if get_config().vad.trim_beginning:
+                return f"Trimmed audio from {self.start:.2f} to {self.end:.2f} seconds using {self.model}."
+            else:
+                return f"Trimmed end of audio to {self.end:.2f} seconds using {self.model}."
+        else:
+            return f"Failed to trim audio using {self.model}."
+
+class VADSystem:
+    def __init__(self):
+        self.silero = None
+        self.whisper = None
+        self.vosk = None
+        self.groq = None
+
+    def init(self):
+        if get_config().vad.is_whisper():
+            if not self.whisper:
+                self.whisper = WhisperVADProcessor()
+        if get_config().vad.is_silero():
+            if not self.silero:
+                self.silero = SileroVADProcessor()
+        if get_config().vad.is_vosk():
+            if not self.vosk:
+                self.vosk = VoskVADProcessor()
+        if get_config().vad.is_groq():
+            if not self.groq:
+                self.groq = GroqVADProcessor()
+
+    def trim_audio_with_vad(self, input_audio, output_audio, game_line):
+        if get_config().vad.do_vad_postprocessing:
+            result = self._do_vad_processing(get_config().vad.selected_vad_model, input_audio, output_audio, game_line)
+            if not result.success and get_config().vad.backup_vad_model != configuration.OFF:
+                logger.info("No voice activity detected, using backup VAD model.")
+                result = self._do_vad_processing(get_config().vad.backup_vad_model, input_audio, output_audio, game_line)
+            if not result.success:
+                if get_config().vad.add_audio_on_no_results:
+                    logger.info("No voice activity detected, using full audio.")
+                    result.output_audio = input_audio
+                else:
+                    logger.info("No voice activity detected.")
+                    return result
+            else:
+                logger.info(result.trim_successful_string())
+            return result
+
+
+    def _do_vad_processing(self, model, input_audio, output_audio, game_line):
+        match model:
+            case configuration.OFF:
+                return VADResult(False, 0, 0, "OFF")
+            case configuration.GROQ:
+                if not self.groq:
+                    self.groq = GroqVADProcessor()
+                return self.groq.process_audio(input_audio, output_audio, game_line)
+            case configuration.SILERO:
+                if not self.silero:
+                    self.silero = SileroVADProcessor()
+                return self.silero.process_audio(input_audio, output_audio, game_line)
+            case configuration.VOSK:
+                if not self.vosk:
+                    self.vosk = VoskVADProcessor()
+                return self.vosk.process_audio(input_audio, output_audio, game_line)
+            case configuration.WHISPER:
+                if not self.whisper:
+                    self.whisper = WhisperVADProcessor()
+                return self.whisper.process_audio(input_audio, output_audio, game_line)
+
+# Base class for VAD systems
+class VADProcessor(ABC):
+    def __init__(self):
+        self.vad_model = None
+        self.vad_system_name = None
+
+    @abstractmethod
+    def _detect_voice_activity(self, input_audio):
+        pass
+
+    def process_audio(self, input_audio, output_audio, game_line):
+        voice_activity = self._detect_voice_activity(input_audio)
+
+        if not voice_activity:
+            logger.info("No voice activity detected in the audio.")
+            return VADResult(False, 0, 0, self.vad_system_name)
+
+        start_time = voice_activity[0]['start'] if voice_activity else 0
+        end_time = voice_activity[-1]['end'] if voice_activity else 0
+
+        # Attempt to fix the end time if the last segment is too short
+        if game_line and game_line.next and len(voice_activity) > 1:
+            audio_length = get_audio_length(input_audio)
+            if 0 > audio_length - voice_activity[-1]['start'] + get_config().audio.beginning_offset:
+                end_time = voice_activity[-2]['end']
+
+        ffmpeg.trim_audio(input_audio, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, output_audio)
+        return VADResult(True, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, self.vad_system_name, output_audio)
+
+class SileroVADProcessor(VADProcessor):
+    def __init__(self):
+        super().__init__()
+        from silero_vad import load_silero_vad
+        self.vad_model = load_silero_vad()
+        self.vad_system_name = SILERO
+
+    def _detect_voice_activity(self, input_audio):
+        from silero_vad import read_audio, get_speech_timestamps
+        temp_wav = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(), suffix='.wav').name
+        ffmpeg.convert_audio_to_wav(input_audio, temp_wav)
+        wav = read_audio(temp_wav)
+        speech_timestamps = get_speech_timestamps(wav, self.vad_model, return_seconds=True)
+        logger.debug(speech_timestamps)
+        return speech_timestamps
+
+class WhisperVADProcessor(VADProcessor):
+    def __init__(self):
+        super().__init__()
+        self.vad_model = self.load_whisper_model()
+        self.vad_system_name = WHISPER
+
+    def load_whisper_model(self):
+        import stable_whisper as whisper
+        if not self.vad_model:
+            with warnings.catch_warnings(action="ignore"):
+                self.vad_model = whisper.load_model(get_config().vad.whisper_model)
+            logger.info(f"Whisper model '{get_config().vad.whisper_model}' loaded.")
+        return self.vad_model
+
+    def _detect_voice_activity(self, input_audio):
+        from stable_whisper import WhisperResult
+        # Convert the audio to 16kHz mono WAV
+        temp_wav = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(), suffix='.wav').name
+        ffmpeg.convert_audio_to_wav(input_audio, temp_wav)
+
+        logger.info('transcribing audio...')
+
+        # Transcribe the audio using Whisper
+        with warnings.catch_warnings(action="ignore"):
+            result: WhisperResult = self.vad_model.transcribe(temp_wav, vad=True, language=get_config().vad.language,
+                                                             temperature=0.0)
+        voice_activity = []
+
+        logger.debug(result.to_dict())
+
+        # Process the segments to extract tokens, timestamps, and confidence
+        for segment in result.segments:
+            logger.debug(segment.to_dict())
+            for word in segment.words:
+                logger.debug(word.to_dict())
+                confidence = word.probability
+                if confidence > .1:
+                    logger.debug(word)
+                    voice_activity.append({
+                        'text': word.word,
+                        'start': word.start,
+                        'end': word.end,
+                        'confidence': word.probability
+                    })
+
+        # Analyze the detected words to decide whether to use the audio
+        should_use = False
+        unique_words = set(word['text'] for word in voice_activity)
+        if len(unique_words) > 1 or not all(item in ['えー', 'ん'] for item in unique_words):
+            should_use = True
+
+        if not should_use:
+            return None
+
+        # Return the detected voice activity and the total duration
+        return voice_activity
+
+# Add a new class for Vosk-based VAD
+class VoskVADProcessor(VADProcessor):
+    def __init__(self):
+        super().__init__()
+        self.vad_model = self._load_vosk_model()
+        self.vad_system_name = VOSK
+
+    def _load_vosk_model(self):
+        if not self.vad_model:
+            import vosk
+            vosk_model_path = self._download_and_cache_vosk_model()
+            self.vad_model = vosk.Model(vosk_model_path)
+            logger.info(f"Vosk model loaded from {vosk_model_path}")
+        return self.vad_model
+
+    def _download_and_cache_vosk_model(self, model_dir="vosk_model_cache"):
+        # Ensure the cache directory exists
+        import requests
+        import zipfile
+        import tarfile
+        if not os.path.exists(os.path.join(get_app_directory(), model_dir)):
+            os.makedirs(os.path.join(get_app_directory(), model_dir))
+
+        # Extract the model name from the URL
+        model_filename = get_config().vad.vosk_url.split("/")[-1]
+        model_path = os.path.join(get_app_directory(), model_dir, model_filename)
+
+        # If the model is already downloaded, skip the download
+        if not os.path.exists(model_path):
+            logger.info(
+                f"Downloading the Vosk model from {get_config().vad.vosk_url}... This will take a while if using large model, ~1G")
+            response = requests.get(get_config().vad.vosk_url, stream=True)
+            with open(model_path, "wb") as file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        file.write(chunk)
+            logger.info("Download complete.")
+
+        # Extract the model if it's a zip or tar file
+        model_extract_path = os.path.join(get_app_directory(), model_dir, "vosk_model")
+        if not os.path.exists(model_extract_path):
+            logger.info("Extracting the Vosk model...")
+            if model_filename.endswith(".zip"):
+                with zipfile.ZipFile(model_path, "r") as zip_ref:
+                    zip_ref.extractall(model_extract_path)
+            elif model_filename.endswith(".tar.gz"):
+                with tarfile.open(model_path, "r:gz") as tar_ref:
+                    tar_ref.extractall(model_extract_path)
+            else:
+                logger.info("Unknown archive format. Model extraction skipped.")
+            logger.info(f"Model extracted to {model_extract_path}.")
+        else:
+            logger.info(f"Model already extracted at {model_extract_path}.")
+
+        # Return the path to the actual model folder inside the extraction directory
+        extracted_folders = os.listdir(model_extract_path)
+        if extracted_folders:
+            actual_model_folder = os.path.join(model_extract_path,
+                                               extracted_folders[0])  # Assuming the first folder is the model
+            return actual_model_folder
+        else:
+            return model_extract_path  # In case there's no subfolder, return the extraction path directly
+
+    def _detect_voice_activity(self, input_audio):
+        import soundfile as sf
+        import vosk
+        import numpy as np
+        # Convert the audio to 16kHz mono WAV
+        temp_wav = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(), suffix='.wav').name
+        ffmpeg.convert_audio_to_wav(input_audio, temp_wav)
+
+        # Initialize recognizer
+        with sf.SoundFile(temp_wav) as audio_file:
+            recognizer = vosk.KaldiRecognizer(self.vad_model, audio_file.samplerate)
+            voice_activity = []
+
+            recognizer.SetWords(True)
+
+            # Process audio in chunks
+            while True:
+                data = audio_file.buffer_read(4000, dtype='int16')
+                if len(data) == 0:
+                    break
+
+                # Convert buffer to bytes using NumPy
+                data_bytes = np.frombuffer(data, dtype='int16').tobytes()
+
+                if recognizer.AcceptWaveform(data_bytes):
+                    pass
+
+            final_result = json.loads(recognizer.FinalResult())
+            if 'result' in final_result:
+                for word in final_result['result']:
+                    if word['conf'] >= 0.90:
+                        voice_activity.append({
+                            'text': word['word'],
+                            'start': word['start'],
+                            'end': word['end']
+                        })
+
+        # Return the detected voice activity
+        return voice_activity
+
+class GroqVADProcessor(VADProcessor):
+    def __init__(self):
+        super().__init__()
+        from groq import Groq
+        self.client = Groq(api_key=get_config().ai.groq_api_key)
+        self.vad_model = self.load_groq_model()
+        self.vad_system_name = GROQ
+
+    def load_groq_model(self):
+        if not self.vad_model:
+            from groq import Groq
+            self.vad_model = Groq()
+            logger.info("Groq model loaded.")
+        return self.vad_model
+
+    def _detect_voice_activity(self, input_audio):
+        try:
+            with open(input_audio, "rb") as file:
+                transcription = self.client.audio.transcriptions.create(
+                    file=(os.path.basename(input_audio), file.read()),
+                    model="whisper-large-v3-turbo",
+                    response_format="verbose_json",
+                    language=get_config().vad.language,
+                    temperature=0.0,
+                    timestamp_granularities=["segment"],
+                    prompt=f"Start detecting speech from the first spoken word. If there is music or background noise, ignore it completely. Be very careful to not hallucinate on silence. If the transcription is anything but language:{get_config().vad.language}, ignore it completely. If the end of the audio seems like the start of a new sentence, ignore it completely.",
+                )
+
+            logger.debug(transcription)
+            speech_segments = []
+            if hasattr(transcription, 'segments'):
+                speech_segments = transcription.segments
+            elif hasattr(transcription, 'words'):
+                speech_segments = transcription.words
+            return speech_segments
+        except Exception as e:
+            logger.error(f"Error detecting voice with Groq: {e}")
+            return [], 0.0
+
+vad_processor = VADSystem()

GameSentenceMiner/web/texthooking_page.py

@@ -10,12 +10,12 @@ from dataclasses import dataclass
 import flask
 import websockets
 
-from GameSentenceMiner.text_log import GameLine, get_line_by_id, initial_time, get_all_lines
+from GameSentenceMiner.util.gsm_utils import TEXT_REPLACEMENTS_FILE
+from GameSentenceMiner.util.text_log import GameLine, get_line_by_id, initial_time
 from flask import request, jsonify, send_from_directory
 import webbrowser
 from GameSentenceMiner import obs
-from GameSentenceMiner.configuration import logger, get_config, DB_PATH, gsm_state
-from GameSentenceMiner.util import TEXT_REPLACEMENTS_FILE
+from GameSentenceMiner.util.configuration import logger, get_config, DB_PATH, gsm_state
 
 port = get_config().general.texthooker_port
 url = f"http://localhost:{port}"
@@ -247,7 +247,7 @@ def clear_history():
 
 async def add_event_to_texthooker(line: GameLine):
     new_event = event_manager.add_gameline(line)
-    await broadcast_message({
+    await websocket_server_thread.send_text({
         'event': 'text_received',
         'sentence': line.text,
         'data': new_event.to_serializable()
@@ -294,37 +294,6 @@ def play_audio():
     return jsonify({}), 200
 
 
-connected_clients = set()
-
-async def websocket_handler(websocket):
-    logger.debug(f"Client connected: {websocket.remote_address}")
-    connected_clients.add(websocket)
-    try:
-        async for message in websocket:
-            try:
-                data = json.loads(message)
-                if 'type' in data and data['type'] == 'get_events':
-                    initial_events = [{'id': 1, 'text': 'Initial event from WebSocket'}, {'id': 2, 'text': 'Another initial event'}]
-                    await websocket.send(json.dumps({'event': 'initial_events', 'payload': initial_events}))
-                elif 'update_checkbox' in data:
-                    print(f"Received checkbox update: {data}")
-                    # Handle checkbox update logic
-                    pass
-                await websocket.send(json.dumps({'response': f'Server received: {message}'}))
-            except json.JSONDecodeError:
-                await websocket.send(json.dumps({'error': 'Invalid JSON format'}))
-    except websockets.exceptions.ConnectionClosedError:
-        print(f"Client disconnected abruptly: {websocket.remote_address}")
-    except websockets.exceptions.ConnectionClosedOK:
-        print(f"Client disconnected gracefully: {websocket.remote_address}")
-    finally:
-        connected_clients.discard(websocket)
-
-async def broadcast_message(message):
-    if connected_clients:
-        for client in connected_clients:
-            await client.send(json.dumps(message))
-
 # async def main():
 #     async with websockets.serve(websocket_handler, "localhost", 8765): # Choose a port for WebSocket
 #         print("WebSocket server started on ws://localhost:8765/ws (adjust as needed)")
@@ -360,7 +329,7 @@ def are_lines_selected():
 
 def reset_checked_lines():
     async def send_reset_message():
-        await broadcast_message({
+        await websocket_server_thread.send_text({
             'event': 'reset_checkboxes',
         })
     event_manager.reset_checked_lines()
@@ -381,25 +350,76 @@ def start_web_server():
 
     app.run(port=port, debug=False) # debug=True provides helpful error messages during development
 
-import signal
 
-async def run_websocket_server(host="0.0.0.0"):
-    global websocket_port
-    websocket = None
-    try:
-        websocket_port = get_config().advanced.texthooker_communication_websocket_port
-        websocket = await websockets.serve(websocket_handler, host, websocket_port)
-        logger.debug(f"WebSocket server started at ws://{host}:{websocket_port}/")
-        await asyncio.Future()  # Keep the server running
-    except asyncio.CancelledError:
-        logger.info("WebSocket server shutting down...")
-    except OSError as e:
-        logger.error(f"TextHooker WebSocket server failed to start on port {websocket_port}: {e}")
-        logger.info("You may need to try a different port in GSM's advanced config, and then update that in the Texthooker's settings.")
-    finally:
-        if websocket:
-            websocket.close()
-        await asyncio.sleep(1)  # Wait before retrying
+websocket_server_thread = None
+websocket_queue = queue.Queue()
+paused = False
+
+
+class WebsocketServerThread(threading.Thread):
+    def __init__(self, read):
+        super().__init__(daemon=True)
+        self._loop = None
+        self.read = read
+        self.clients = set()
+        self._event = threading.Event()
+
+    @property
+    def loop(self):
+        self._event.wait()
+        return self._loop
+
+    async def send_text_coroutine(self, message):
+        for client in self.clients:
+            await client.send(message)
+
+    async def server_handler(self, websocket):
+        self.clients.add(websocket)
+        try:
+            async for message in websocket:
+                if self.read and not paused:
+                    websocket_queue.put(message)
+                    try:
+                        await websocket.send('True')
+                    except websockets.exceptions.ConnectionClosedOK:
+                        pass
+                else:
+                    try:
+                        await websocket.send('False')
+                    except websockets.exceptions.ConnectionClosedOK:
+                        pass
+        except websockets.exceptions.ConnectionClosedError:
+            pass
+        finally:
+            self.clients.remove(websocket)
+
+    async def send_text(self, text):
+        if text:
+            return asyncio.run_coroutine_threadsafe(
+                self.send_text_coroutine(json.dumps(text)), self.loop)
+
+    def stop_server(self):
+        self.loop.call_soon_threadsafe(self._stop_event.set)
+
+    def run(self):
+        async def main():
+            self._loop = asyncio.get_running_loop()
+            self._stop_event = stop_event = asyncio.Event()
+            self._event.set()
+            while True:
+                try:
+                    self.server = start_server = websockets.serve(self.server_handler,
+                                                                  "0.0.0.0",
+                                                                  get_config().advanced.texthooker_communication_websocket_port,
+                                                                  max_size=1000000000)
+                    async with start_server:
+                        await stop_event.wait()
+                    return
+                except Exception as e:
+                    logger.warning(f"WebSocket server encountered an error: {e}. Retrying...")
+                    await asyncio.sleep(1)
+
+        asyncio.run(main())
 
 def handle_exit_signal(loop):
     logger.info("Received exit signal. Shutting down...")
@@ -407,13 +427,16 @@ def handle_exit_signal(loop):
         task.cancel()
 
 async def texthooker_page_coro():
+    global websocket_server_thread
     # Run the WebSocket server in the asyncio event loop
     flask_thread = threading.Thread(target=start_web_server)
     flask_thread.daemon = True
     flask_thread.start()
 
+    websocket_server_thread = WebsocketServerThread(read=True)
+    websocket_server_thread.start()
+
     # Keep the main asyncio event loop running (for the WebSocket server)
-    await run_websocket_server()
 
 def run_text_hooker_page():
     try:

{gamesentenceminer-2.9.3.dist-info → gamesentenceminer-2.9.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.9.3
+Version: 2.9.5
 Summary: A tool for mining sentences from games.
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
@@ -21,7 +21,6 @@ Requires-Dist: soundfile~=0.12.1
 Requires-Dist: toml~=0.10.2
 Requires-Dist: psutil~=6.0.0
 Requires-Dist: rapidfuzz~=3.9.7
-Requires-Dist: obs-websocket-py~=1.0
 Requires-Dist: plyer~=2.1.0
 Requires-Dist: keyboard~=0.13.5
 Requires-Dist: websockets~=15.0.1
@@ -37,7 +36,7 @@ Requires-Dist: google-generativeai
 Requires-Dist: pygetwindow; sys_platform == "win32"
 Requires-Dist: flask
 Requires-Dist: groq
-Requires-Dist: obsws-python
+Requires-Dist: obsws-python~=1.7.2
 Requires-Dist: Flask-SocketIO
 Dynamic: license-file
 

gamesentenceminer-2.9.5.dist-info/RECORD

@@ -0,0 +1,57 @@
+GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/anki.py,sha256=CuzVqzuFtZnbMbU2Zk-sxNGwSgyCpv5RLL7lOOX0Meg,14972
+GameSentenceMiner/config_gui.py,sha256=r-ASCXVNS4Io6Ej3svwC8aJEWc9Rc7u-pzfsAwD4ru8,82079
+GameSentenceMiner/gametext.py,sha256=mM-gw1d7c2EEvMUznaAevTQFLswNZavCuxMXhA9pV4g,6251
+GameSentenceMiner/gsm.py,sha256=t5rW4njIzWKi9zANU6W2JZJUbxWBOsQak-irHr7a85Q,27741
+GameSentenceMiner/obs.py,sha256=jdAKQFnXlviMupRUKBuK68Q1u8yEZNKBgFnvIq1hhnc,14810
+GameSentenceMiner/vad.py,sha256=Gk_VthD7mDp3-wM_S6bEv8ykGmqzCDbbcRiaEBzAE_o,14835
+GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/ai/ai_prompting.py,sha256=tPDiTHlrfZul0hlvEFgZS4V_6oaHkVb-4v79Sd4gtlM,10018
+GameSentenceMiner/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/assets/icon.png,sha256=9GRL8uXUAgkUSlvbm9Pv9o2poFVRGdW6s2ub_DeUD9M,937624
+GameSentenceMiner/assets/icon128.png,sha256=l90j7biwdz5ahwOd5wZ-406ryEV9Pan93dquJQ3e1CI,18395
+GameSentenceMiner/assets/icon256.png,sha256=JEW46wOrG1KR-907rvFaEdNbPtj5gu0HJmG7qUnIHxQ,51874
+GameSentenceMiner/assets/icon32.png,sha256=Kww0hU_qke9_22wBuO_Nq0Dv2SfnOLwMhCyGgbgXdg8,6089
+GameSentenceMiner/assets/icon512.png,sha256=HxUj2GHjyQsk8NV433256UxU9phPhtjCY-YB_7W4sqs,192487
+GameSentenceMiner/assets/icon64.png,sha256=N8xgdZXvhqVQP9QUK3wX5iqxX9LxHljD7c-Bmgim6tM,9301
+GameSentenceMiner/assets/pickaxe.png,sha256=VfIGyXyIZdzEnVcc4PmG3wszPMO1W4KCT7Q_nFK6eSE,1403829
+GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=fEQ2o2NXksGRHpueO8c4TfAp75GEdAtAr1ngTFOsdpg,2257
+GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
+GameSentenceMiner/ocr/owocr_area_selector.py,sha256=71trzwz9Isyy-kN9mLS8vIX-giC8Lkin4slLXaxudac,47162
+GameSentenceMiner/ocr/owocr_helper.py,sha256=FQXk5PSCS9gWtcgoIFsPxjVELUwA4Dg1hEX83902K0Q,18114
+GameSentenceMiner/owocr/owocr/__init__.py,sha256=opjBOyGGyEqZCE6YdZPnyt7nVfiwyELHsXA0jAsjm14,25
+GameSentenceMiner/owocr/owocr/__main__.py,sha256=XQaqZY99EKoCpU-gWQjNbTs7Kg17HvBVE7JY8LqIE0o,157
+GameSentenceMiner/owocr/owocr/config.py,sha256=qM7kISHdUhuygGXOxmgU6Ef2nwBShrZtdqu4InDCViE,8103
+GameSentenceMiner/owocr/owocr/lens_betterproto.py,sha256=oNoISsPilVVRBBPVDtb4-roJtAhp8ZAuFTci3TGXtMc,39141
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=y8RHHaJw8M4BG4CbbtIw0DrV8KP9RjbJNJxjM5v91oU,42236
+GameSentenceMiner/owocr/owocr/run.py,sha256=jFN7gYYriHgfqORJiBTz8mPkQsDJ6ZugA0_ATWUxk-U,54750
+GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
+GameSentenceMiner/util/communication/__init__.py,sha256=xh__yn2MhzXi9eLi89PeZWlJPn-cbBSjskhi1BRraXg,643
+GameSentenceMiner/util/communication/send.py,sha256=Wki9qIY2CgYnuHbmnyKVIYkcKAN_oYS4up93XMikBaI,222
+GameSentenceMiner/util/communication/websocket.py,sha256=gPgxA2R2U6QZJjPqbUgODC87gtacPhmuC8lCprIkSmA,3287
+GameSentenceMiner/util/downloader/Untitled_json.py,sha256=RUUl2bbbCpUDUUS0fP0tdvf5FngZ7ILdA_J5TFYAXUQ,15272
+GameSentenceMiner/util/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/util/downloader/download_tools.py,sha256=mvnOjDHFlV1AbjHaNI7mdnC5_CH5k3N4n1ezqzzbzGA,8139
+GameSentenceMiner/util/downloader/oneocr_dl.py,sha256=o3ANp5IodEQoQ8GPcJdg9Y8JzA_lictwnebFPwwUZVk,10144
+GameSentenceMiner/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/web/texthooking_page.py,sha256=RR70Vgde3wNHarQHbB-LBbEP-z95vRD5rtlW0GgdjmQ,15037
+GameSentenceMiner/web/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/web/static/apple-touch-icon.png,sha256=OcMI8af_68DA_tweOsQ5LytTyMwm7-hPW07IfrOVgEs,46132
+GameSentenceMiner/web/static/favicon-96x96.png,sha256=lOePzjiKl1JY2J1kT_PMdyEnrlJmi5GWbmXJunM12B4,16502
+GameSentenceMiner/web/static/favicon.ico,sha256=7d25r_FBqRSNsAoEHpSzNoT7zyVt2DJRLNDNq_HYoX8,15086
+GameSentenceMiner/web/static/favicon.svg,sha256=x305AP6WlXGtrXIZlaQspdLmwteoFYUoe5FyJ9MYlJ8,11517
+GameSentenceMiner/web/static/site.webmanifest,sha256=kaeNT-FjFt-T7JGzOhXH7YSqsrDeiplZ2kDxCN_CFU4,436
+GameSentenceMiner/web/static/style.css,sha256=bPZK0NVMuyRl5NNDuT7ZTzVLKlvSsdmeVHmAW4y5FM0,7001
+GameSentenceMiner/web/static/web-app-manifest-192x192.png,sha256=EfSNnBmsSaLfESbkGfYwbKzcjKOdzuWo18ABADfN974,51117
+GameSentenceMiner/web/static/web-app-manifest-512x512.png,sha256=wyqgCWCrLEUxSRXmaA3iJEESd-vM-ZmlTtZFBY4V8Pk,230819
+GameSentenceMiner/web/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/web/templates/index.html,sha256=HZKiIjiGJV8PGQ9T2aLDUNSfJn71qOwbYCjbRuSIjpY,213583
+GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
+GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
+gamesentenceminer-2.9.5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.9.5.dist-info/METADATA,sha256=_SsLMuzhBNnvzZALCJLBX0besj87Wxr6TOR3xpV3h1Q,7250
+gamesentenceminer-2.9.5.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+gamesentenceminer-2.9.5.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.9.5.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.9.5.dist-info/RECORD,,