GameSentenceMiner 2.9.4__py3-none-any.whl → 2.9.6__py3-none-any.whl

GameSentenceMiner/{ffmpeg.py → util/ffmpeg.py}

@@ -1,11 +1,13 @@
-import shutil
+import subprocess
 import tempfile
+import time
+from pathlib import Path
 
-import GameSentenceMiner.configuration
-from GameSentenceMiner import obs, util, configuration
-from GameSentenceMiner.configuration import *
-from GameSentenceMiner.text_log import initial_time
-from GameSentenceMiner.util import *
+from GameSentenceMiner import obs
+from GameSentenceMiner.util.gsm_utils import make_unique_file_name, get_file_modification_time
+from GameSentenceMiner.util import configuration
+from GameSentenceMiner.util.configuration import *
+from GameSentenceMiner.util.text_log import initial_time
 
 
 def get_ffmpeg_path():
@@ -34,11 +36,11 @@ def call_frame_extractor(video_path, timestamp):
         # Construct the path to the frame extractor script
         script_path = os.path.join(current_dir, "ss_selector.py")  # Replace with the actual script name if different
 
-        logger.info(' '.join([sys.executable, "-m", "GameSentenceMiner.ss_selector", video_path, str(timestamp)]))
+        logger.info(' '.join([sys.executable, "-m", "GameSentenceMiner.util.ss_selector", video_path, str(timestamp)]))
 
         # Run the script using subprocess.run()
         result = subprocess.run(
-            [sys.executable, "-m", "GameSentenceMiner.ss_selector", video_path, str(timestamp), get_config().screenshot.screenshot_timing_setting],  # Use sys.executable
+            [sys.executable, "-m", "GameSentenceMiner.util.ss_selector", video_path, str(timestamp), get_config().screenshot.screenshot_timing_setting],  # Use sys.executable
             capture_output=True,
             text=True,  # Get output as text
             check=False  # Raise an exception for non-zero exit codes
@@ -297,6 +299,7 @@ def trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_l
     trimmed_audio = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(),
                                                 suffix=f".{get_config().audio.extension}").name
     start_trim_time, total_seconds, total_seconds_after_offset = get_video_timings(video_path, game_line, anki_card_creation_time)
+    end_trim_time = ""
 
     ffmpeg_command = ffmpeg_base_command_list + [
         "-i", untrimmed_audio,
@@ -320,6 +323,11 @@ def trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_l
 
     logger.debug(f"{total_seconds_after_offset} trimmed off of beginning")
 
+    if end_trim_time:
+        logger.info(f"Audio Extracted and trimmed to {start_trim_time} seconds with end time {end_trim_time}")
+    else:
+        logger.info(f"Audio Extracted and trimmed to {start_trim_time} seconds")
+
     logger.debug(f"Audio trimmed and saved to {trimmed_audio}")
     return trimmed_audio
 
@@ -365,8 +373,8 @@ def reencode_file_with_user_config(input_file, final_output_audio, user_ffmpeg_o
 
 
 def create_temp_file_with_same_name(input_file: str):
-    split = input_file.split(".")
-    return f"{split[0]}_temp.{split[1]}"
+    path = Path(input_file)
+    return str(path.with_name(f"{path.stem}_temp{path.suffix}"))
 
 
 def replace_file_with_retry(temp_file, input_file, retries=5, delay=1):

GameSentenceMiner/{util.py → util/gsm_utils.py}

@@ -7,25 +7,14 @@ import subprocess
 import threading
 import time
 from datetime import datetime
+from pathlib import Path
 
 from rapidfuzz import process
 
-from GameSentenceMiner.configuration import logger, get_config, get_app_directory
+from GameSentenceMiner.util.configuration import logger, get_config, get_app_directory
 
 SCRIPTS_DIR = r"E:\Japanese Stuff\agent-v0.1.4-win32-x64\data\scripts"
 
-# Global variables to control script execution
-keep_running = True
-lock = threading.Lock()
-last_mined_line = None
-
-def get_last_mined_line():
-    return last_mined_line
-
-def set_last_mined_line(line):
-    global last_mined_line
-    last_mined_line = line
-
 def run_new_thread(func):
     thread = threading.Thread(target=func, daemon=True)
     thread.start()
@@ -33,13 +22,9 @@ def run_new_thread(func):
 
 
 def make_unique_file_name(path):
-    split = path.rsplit('.', 1)
-    filename = split[0]
-    extension = split[1]
-
+    path = Path(path)
     current_time = datetime.now().strftime('%Y-%m-%d-%H-%M-%S-%f')[:-3]
-
-    return f"{filename}_{current_time}.{extension}"
+    return f"{path.stem}_{current_time}{path.suffix}"
 
 def sanitize_filename(filename):
         return re.sub(r'[ <>:"/\\|?*\x00-\x1F]', '', filename)
@@ -194,18 +179,6 @@ def wait_for_stable_file(file_path, timeout=10, check_interval=0.1):
     logger.warning("File size did not stabilize within the timeout period. Continuing...")
     return False
 
-
-def import_vad_models():
-    silero_trim, whisper_helper, vosk_helper = None, None, None
-    if get_config().vad.is_silero():
-        from GameSentenceMiner.vad import silero_trim
-    if get_config().vad.is_whisper():
-        from GameSentenceMiner.vad import whisper_helper
-    if get_config().vad.is_vosk():
-        from GameSentenceMiner.vad import vosk_helper
-    return silero_trim, whisper_helper, vosk_helper
-
-
 def isascii(s: str):
     try:
         return s.isascii()

GameSentenceMiner/{model.py → util/model.py}

@@ -3,7 +3,7 @@ from typing import Optional, List
 
 from dataclasses_json import dataclass_json
 
-from GameSentenceMiner.configuration import get_config, logger, save_current_config
+from GameSentenceMiner.util.configuration import get_config, logger, save_current_config
 
 
 # OBS

GameSentenceMiner/{notification.py → util/notification.py}

@@ -1,8 +1,6 @@
-import platform
-
 import requests
 from plyer import notification
-from GameSentenceMiner.configuration import logger, is_windows
+from GameSentenceMiner.util.configuration import logger, is_windows
 
 if is_windows():
     from win10toast import ToastNotifier
@@ -21,7 +19,7 @@ if is_windows():
 else:
     notifier = notification
 
-def open_browser_window(note_id):
+def open_browser_window(note_id, query=None):
     url = "http://localhost:8765"
     headers = {'Content-Type': 'application/json'}
 
@@ -29,7 +27,7 @@ def open_browser_window(note_id):
         "action": "guiBrowse",
         "version": 6,
         "params": {
-            "query": f"nid:{note_id}"
+            "query": f"nid:{note_id}" if not query else query,
         }
     }
 

GameSentenceMiner/{package.py → util/package.py}

@@ -1,9 +1,8 @@
-import os
 from importlib import metadata
 
 import requests
 
-from GameSentenceMiner.configuration import logger, get_app_directory
+from GameSentenceMiner.util.configuration import logger
 
 PACKAGE_NAME = "GameSentenceMiner"
 

GameSentenceMiner/{ss_selector.py → util/ss_selector.py}

@@ -4,10 +4,11 @@ import subprocess
 import os
 import sys
 
-from GameSentenceMiner import ffmpeg
-from GameSentenceMiner.configuration import get_temporary_directory, logger
-from GameSentenceMiner.ffmpeg import ffmpeg_base_command_list
-from GameSentenceMiner.util import sanitize_filename
+from GameSentenceMiner.util.gsm_utils import sanitize_filename
+from GameSentenceMiner.util.configuration import get_temporary_directory, logger
+from GameSentenceMiner.util.ffmpeg import ffmpeg_base_command_list
+from GameSentenceMiner.util import ffmpeg
+
 
 def extract_frames(video_path, timestamp, temp_dir, mode):
     frame_paths = []

GameSentenceMiner/{text_log.py → util/text_log.py}

@@ -4,9 +4,9 @@ from datetime import datetime
 from difflib import SequenceMatcher
 from typing import Optional
 
-from GameSentenceMiner.configuration import logger, get_config
-from GameSentenceMiner.model import AnkiCard
-from GameSentenceMiner.util import remove_html_and_cloze_tags
+from GameSentenceMiner.util.gsm_utils import remove_html_and_cloze_tags
+from GameSentenceMiner.util.configuration import logger, get_config
+from GameSentenceMiner.util.model import AnkiCard
 
 initial_time = datetime.now()
 

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}"
@@ -350,7 +350,6 @@ def start_web_server():
 
     app.run(port=port, debug=False) # debug=True provides helpful error messages during development
 
-import signal
 
 websocket_server_thread = None
 websocket_queue = queue.Queue()
@@ -407,12 +406,18 @@ class WebsocketServerThread(threading.Thread):
             self._loop = asyncio.get_running_loop()
             self._stop_event = stop_event = asyncio.Event()
             self._event.set()
-            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()
+            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())
 

{gamesentenceminer-2.9.4.dist-info → gamesentenceminer-2.9.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.9.4
+Version: 2.9.6
 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