GameSentenceMiner 2.8.26__py3-none-any.whl → 2.8.28__py3-none-any.whl

GameSentenceMiner/ai/ai_prompting.py

@@ -99,7 +99,7 @@ class GeminiAI(AIManager):
             genai.configure(api_key=self.ai_config.api_key)
             model_name = self.ai_config.model
             self.model = genai.GenerativeModel(model_name)
-            self.logger.info(f"GeminiAIManager initialized with model: {model_name}")
+            self.logger.debug(f"GeminiAIManager initialized with model: {model_name}")
         except Exception as e:
             self.logger.error(f"Failed to initialize Gemini API: {e}")
             self.model = None
@@ -134,7 +134,7 @@ class GroqAI(AIManager):
         self.model_name = self.ai_config.model
         try:
             self.client = Groq(api_key=self.api_key)
-            self.logger.info(f"GroqAIManager initialized with model: {self.model_name}")
+            self.logger.debug(f"GroqAIManager initialized with model: {self.model_name}")
         except Exception as e:
             self.logger.error(f"Failed to initialize Groq client: {e}")
             self.client = None
@@ -187,7 +187,7 @@ def get_ai_prompt_result(lines: List[GameLine], sentence: str, current_line: Gam
             return ""
         return ai_manager.process(lines, sentence, current_line, game_title)
     except Exception as e:
-        logger.info("Error caught while trying to get AI prompt result. Check logs for more details.")
+        logger.error("Error caught while trying to get AI prompt result. Check logs for more details.")
         logger.debug(e)
         return ""
 

GameSentenceMiner/anki.py

@@ -8,7 +8,7 @@ from datetime import datetime, timedelta
 from requests import post
 
 from GameSentenceMiner import obs, util, notification, ffmpeg
-from GameSentenceMiner.ai.ai_prompting import GeminiAI, get_ai_prompt_result
+from GameSentenceMiner.ai.ai_prompting import get_ai_prompt_result
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.configuration import get_config
 from GameSentenceMiner.model import AnkiCard
@@ -28,7 +28,7 @@ card_queue = []
 
 
 def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='', tango='', reuse_audio=False,
-                     should_update_audio=True, ss_time=0, game_line=None, selected_lines=None):
+                     should_update_audio=True, ss_time=0, game_line=None, selected_lines=None, prev_ss_timing=0):
     global audio_in_anki, screenshot_in_anki, prev_screenshot_in_anki
     update_audio = should_update_audio and (get_config().anki.sentence_audio_field and not
     last_note.get_field(get_config().anki.sentence_audio_field) or get_config().anki.overwrite_audio)
@@ -45,7 +45,14 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
             if get_config().paths.remove_screenshot:
                 os.remove(screenshot)
         if get_config().anki.previous_image_field:
-            prev_screenshot = ffmpeg.get_screenshot(video_path, ffmpeg.get_screenshot_time(video_path, selected_lines[0].prev if selected_lines else game_line.prev))
+            if prev_ss_timing != 0:
+                try:
+                    prev_screenshot = ffmpeg.get_screenshot(video_path, prev_ss_timing)
+                except Exception as e:
+                    logger.error(f"Error getting previous screenshot based on VAD, Falling back to previous logic: {e}")
+                    prev_screenshot = ffmpeg.get_screenshot(video_path, ffmpeg.get_screenshot_time(video_path, selected_lines[0].prev if selected_lines else game_line.prev))
+            else:
+                prev_screenshot = ffmpeg.get_screenshot(video_path, ffmpeg.get_screenshot_time(video_path, selected_lines[0].prev if selected_lines else game_line.prev))
             prev_screenshot_in_anki = store_media_file(prev_screenshot)
             if get_config().paths.remove_screenshot:
                 os.remove(prev_screenshot)
@@ -69,7 +76,7 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
             get_config().anki.sentence_field)
         translation = get_ai_prompt_result(get_all_lines(), sentence_to_translate,
                                  game_line, get_current_game())
-        logger.info(translation)
+        logger.info(f"AI prompt Result: {translation}")
         note['fields'][get_config().ai.anki_field] = translation
 
     if prev_screenshot_in_anki:
@@ -99,7 +106,7 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
 
 
 def open_audio_in_external(fileabspath, shell=False):
-    logger.info(f"Opening audio: {fileabspath} in external Program: {get_config().audio.external_tool}")
+    logger.info(f"Opening audio in external program...")
     if shell:
         subprocess.Popen(f' "{get_config().audio.external_tool}" "{fileabspath}" ', shell=True)
     else:
@@ -271,8 +278,8 @@ def update_new_card():
     if not last_card or not check_tags_for_should_update(last_card):
         return
     use_prev_audio = sentence_is_same_as_previous(last_card)
-    logger.info(f"last mined line: {util.get_last_mined_line()}, current sentence: {get_sentence(last_card)}")
-    logger.info(f"use previous audio: {use_prev_audio}")
+    logger.debug(f"last mined line: {util.get_last_mined_line()}, current sentence: {get_sentence(last_card)}")
+    logger.info(f"New card using previous audio: {use_prev_audio}")
     if get_config().obs.get_game_from_scene:
         obs.update_current_game()
     if use_prev_audio:

GameSentenceMiner/ffmpeg.py

@@ -42,7 +42,7 @@ def get_screenshot(video_file, screenshot_timing):
     # Run the command
     subprocess.run(ffmpeg_command)
 
-    logger.info(f"Screenshot saved to: {output_image}")
+    logger.debug(f"Screenshot saved to: {output_image}")
 
     return output_image
 
@@ -50,14 +50,16 @@ def get_screenshot_for_line(video_file, game_line):
     return get_screenshot(video_file, get_screenshot_time(video_file, game_line))
 
 
-def get_screenshot_time(video_path, game_line, default_beginning=False, vad_beginning=None, vad_end=None, doing_multi_line=False):
+def get_screenshot_time(video_path, game_line, default_beginning=False, vad_result=None, doing_multi_line=False, previous_line=False):
     if game_line:
         line_time = game_line.time
     else:
         # Assuming initial_time is defined elsewhere if game_line is None
         line_time = initial_time
-
-    logger.info("Calculating screenshot time for line: " + str(game_line.text))
+    if previous_line:
+        logger.debug(f"Calculating screenshot time for previous line: {str(game_line.text)}")
+    else:
+        logger.debug("Calculating screenshot time for line: " + str(game_line.text))
 
     file_length = get_video_duration(video_path)
     file_mod_time = get_file_modification_time(video_path)
@@ -68,28 +70,24 @@ def get_screenshot_time(video_path, game_line, default_beginning=False, vad_begi
     screenshot_offset = get_config().screenshot.seconds_after_line
 
     # Calculate screenshot time from the beginning by adding the offset
-    if vad_beginning and vad_end and not doing_multi_line:
-        logger.debug("Using VAD to determine screenshot time")
-        screenshot_time_from_beginning = line_timestamp_in_video + vad_end - 0.1
+    if vad_result and vad_result.success and not doing_multi_line:
+        screenshot_time_from_beginning = line_timestamp_in_video + vad_result.end - 1
+        logger.info(f"Using VAD result {vad_result} for screenshot time: {screenshot_time_from_beginning} seconds from beginning of replay")
     elif get_config().screenshot.screenshot_timing_setting == "beginning":
-        logger.debug("Using beginning of line for screenshot")
         screenshot_time_from_beginning = line_timestamp_in_video + screenshot_offset
+        logger.info(f"Using 'beginning' setting for screenshot time: {screenshot_time_from_beginning} seconds from beginning of replay")
     elif get_config().screenshot.screenshot_timing_setting == "middle":
         if game_line.next:
-            logger.debug("Finding time between lines for screenshot")
             screenshot_time_from_beginning = line_timestamp_in_video + ((game_line.next.time - game_line.time).total_seconds() / 2) + screenshot_offset
         else:
-            logger.debug("Using end of line for screenshot")
             screenshot_time_from_beginning = file_length - abs(screenshot_offset)
+        logger.info(f"Using 'middle' setting for screenshot time: {screenshot_time_from_beginning} seconds from beginning of replay")
     elif get_config().screenshot.screenshot_timing_setting == "end":
-        logger.debug("Using end of line for screenshot")
         if game_line.next:
-            logger.debug("Finding time between lines for screenshot")
             screenshot_time_from_beginning = line_timestamp_in_video + (game_line.next.time - game_line.time).total_seconds() - screenshot_offset
         else:
-            logger.debug("Using end of video for screenshot")
-            # If no next line, use the end of the video
             screenshot_time_from_beginning = file_length - screenshot_offset
+        logger.info(f"Using 'end' setting for screenshot time: {screenshot_time_from_beginning} seconds from beginning of replay")
     else:
         logger.error(f"Invalid screenshot timing setting: {get_config().screenshot.screenshot_timing_setting}")
         screenshot_time_from_beginning = line_timestamp_in_video + screenshot_offset
@@ -100,14 +98,9 @@ def get_screenshot_time(video_path, game_line, default_beginning=False, vad_begi
              f"Calculated screenshot time ({screenshot_time_from_beginning:.2f}s) is out of bounds for video (length {file_length:.2f}s)."
         )
         if default_beginning:
-            logger.info("Defaulting to using the beginning of the video (1.0s)")
-            # Return time for the start of the video
             return 1.0
-        logger.info(f"Defaulting to using the end of the video ({file_length:.2f}s)")
         return file_length - screenshot_offset
 
-    logger.info("Screenshot time from beginning: " + str(screenshot_time_from_beginning))
-
     # Return the calculated time from the beginning
     return screenshot_time_from_beginning
 
@@ -178,10 +171,10 @@ def get_audio_and_trim(video_path, game_line, next_line_time, anki_card_creation
 
     if codec == get_config().audio.extension:
         codec_command = ['-c:a', 'copy']
-        logger.info(f"Extracting {get_config().audio.extension} from video")
+        logger.debug(f"Extracting {get_config().audio.extension} from video")
     else:
         codec_command = ["-c:a", f"{supported_formats[get_config().audio.extension]}"]
-        logger.info(f"Re-encoding {codec} to {get_config().audio.extension}")
+        logger.debug(f"Re-encoding {codec} to {get_config().audio.extension}")
 
     untrimmed_audio = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(),
                                                   suffix=f"_untrimmed.{get_config().audio.extension}").name
@@ -231,7 +224,7 @@ def trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_l
         minutes, seconds = divmod(remainder, 60)
         end_trim_time = "{:02}:{:02}:{:06.3f}".format(int(hours), int(minutes), seconds)
         ffmpeg_command.extend(['-to', end_trim_time])
-        logger.info(
+        logger.debug(
             f"Looks Like this is mining from History, or Multiple Lines were selected Trimming end of audio to {end_trim_time}")
 
     ffmpeg_command.extend([
@@ -244,7 +237,7 @@ def trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_l
 
     logger.info(f"{total_seconds_after_offset} trimmed off of beginning")
 
-    logger.info(f"Audio trimmed and saved to {trimmed_audio}")
+    logger.debug(f"Audio trimmed and saved to {trimmed_audio}")
     return trimmed_audio
 
 def get_video_timings(video_path, game_line, anki_card_creation_time=None):
@@ -269,7 +262,7 @@ def get_video_timings(video_path, game_line, anki_card_creation_time=None):
 
 
 def reencode_file_with_user_config(input_file, final_output_audio, user_ffmpeg_options):
-    logger.info(f"Re-encode running with settings:  {user_ffmpeg_options}")
+    logger.debug(f"Re-encode running with settings:  {user_ffmpeg_options}")
     temp_file = create_temp_file_with_same_name(input_file)
     command = ffmpeg_base_command_list + [
         "-i", input_file,
@@ -297,7 +290,6 @@ def replace_file_with_retry(temp_file, input_file, retries=5, delay=1):
     for attempt in range(retries):
         try:
             shutil.move(temp_file, input_file)
-            logger.info(f'Re-encode Finished!')
             return
         except OSError as e:
             if attempt < retries - 1:

GameSentenceMiner/gsm.py

@@ -1,5 +1,7 @@
 import asyncio
 
+from GameSentenceMiner.vad.result import VADResult
+
 try:
     import os.path
     import signal
@@ -134,32 +136,38 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
                 if get_config().anki.sentence_audio_field and get_config().audio.enabled:
                     logger.debug("Attempting to get audio from video")
-                    final_audio_output, should_update_audio, vad_trimmed_audio, vad_beginning, vad_end = VideoToAudioHandler.get_audio(
+                    final_audio_output, vad_result, vad_trimmed_audio = VideoToAudioHandler.get_audio(
                         start_line,
                         line_cutoff,
                         video_path,
                         anki_card_creation_time)
                 else:
                     final_audio_output = ""
-                    should_update_audio = False
+                    vad_result = VADResult(False, 0, 0)
                     vad_trimmed_audio = ""
-                    vad_beginning = 0
-                    vad_end = 0
                     if not get_config().audio.enabled:
                         logger.info("Audio is disabled in config, skipping audio processing!")
                     elif not get_config().anki.sentence_audio_field:
                         logger.info("No SentenceAudio Field in config, skipping audio processing!")
 
-                ss_timing = ffmpeg.get_screenshot_time(video_path, mined_line, vad_beginning=vad_beginning, vad_end=vad_end, doing_multi_line=bool(selected_lines))
+                ss_timing = ffmpeg.get_screenshot_time(video_path, mined_line, vad_result=vad_result, doing_multi_line=bool(selected_lines))
+                if get_config().anki.previous_image_field and get_config().vad.do_vad_postprocessing:
+                    prev_ss_timing = ffmpeg.get_screenshot_time(video_path, mined_line.prev,
+                                                                vad_result=VideoToAudioHandler.get_audio(game_line=mined_line.prev,
+                                                                 next_line_time=mined_line.time,
+                                                                 video_path=video_path,
+                                                                 anki_card_creation_time=anki_card_creation_time,
+                                                                 timing_only=True) ,doing_multi_line=bool(selected_lines), previous_line=True)
 
                 if get_config().anki.update_anki and last_note:
                     anki.update_anki_card(last_note, note, audio_path=final_audio_output, video_path=video_path,
                                           tango=tango,
-                                          should_update_audio=should_update_audio,
+                                          should_update_audio=vad_result.success,
                                           ss_time=ss_timing,
                                           game_line=start_line,
-                                          selected_lines=selected_lines)
-                elif get_config().features.notify_on_update and should_update_audio:
+                                          selected_lines=selected_lines,
+                                          prev_ss_timing=prev_ss_timing)
+                elif get_config().features.notify_on_update and vad_result.success:
                     notification.send_audio_generated_notification(vad_trimmed_audio)
         except Exception as e:
             logger.error(f"Failed Processing and/or adding to Anki: Reason {e}")
@@ -173,7 +181,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
 
     @staticmethod
-    def get_audio(game_line, next_line_time, video_path, anki_card_creation_time=None, temporary=False):
+    def get_audio(game_line, next_line_time, video_path, anki_card_creation_time=None, temporary=False, timing_only=False):
         trimmed_audio = get_audio_and_trim(video_path, game_line, next_line_time, anki_card_creation_time)
         if temporary:
             return trimmed_audio
@@ -181,23 +189,23 @@ class VideoToAudioHandler(FileSystemEventHandler):
             f"{os.path.abspath(configuration.get_temporary_directory())}/{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}")
         final_audio_output = make_unique_file_name(os.path.join(get_config().paths.audio_destination,
                                                                 f"{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}"))
-        should_update_audio = True
-        vad_beginning, vad_end = 0, 0
+        result = VADResult(False, 0, 0)
         if get_config().vad.do_vad_postprocessing:
-            should_update_audio, vad_beginning, vad_end = do_vad_processing(get_config().vad.selected_vad_model, trimmed_audio, vad_trimmed_audio)
-            if not should_update_audio:
-                should_update_audio, vad_beginning, vad_end = do_vad_processing(get_config().vad.selected_vad_model, trimmed_audio,
+            result = do_vad_processing(get_config().vad.selected_vad_model, trimmed_audio, vad_trimmed_audio)
+            if not result.success:
+                result = do_vad_processing(get_config().vad.selected_vad_model, trimmed_audio,
                                                         vad_trimmed_audio)
-            if not should_update_audio and get_config().vad.add_audio_on_no_results:
+            if not result.success and get_config().vad.add_audio_on_no_results:
                 logger.info("No voice activity detected, using full audio.")
                 vad_trimmed_audio = trimmed_audio
-                should_update_audio = True
+        if timing_only:
+            return result
         if get_config().audio.ffmpeg_reencode_options and os.path.exists(vad_trimmed_audio):
             ffmpeg.reencode_file_with_user_config(vad_trimmed_audio, final_audio_output,
                                                   get_config().audio.ffmpeg_reencode_options)
         elif os.path.exists(vad_trimmed_audio):
             shutil.move(vad_trimmed_audio, final_audio_output)
-        return final_audio_output, should_update_audio, vad_trimmed_audio, vad_beginning, vad_end
+        return final_audio_output, result, vad_trimmed_audio
 
 
 def do_vad_processing(model, trimmed_audio, vad_trimmed_audio, second_pass=False):

GameSentenceMiner/ocr/owocr_helper.py

@@ -207,7 +207,6 @@ rectangles = None
 
 def do_second_ocr(ocr1_text, rectangle_index, time, img):
     global twopassocr, ocr2, last_ocr1_results, last_ocr2_results
-    last_result = ([], -1)
     try:
         orig_text, text = run.process_and_write_results(img, None, None, None, None,
                                                         engine=ocr2)
@@ -218,6 +217,7 @@ def do_second_ocr(ocr1_text, rectangle_index, time, img):
         img.save(os.path.join(get_temporary_directory(), "last_successful_ocr.png"))
         last_ocr2_results[rectangle_index] = text
         send_result(text, time)
+        img.close()
     except json.JSONDecodeError:
         print("Invalid JSON received.")
     except Exception as e:

GameSentenceMiner/owocr/owocr/config.py

@@ -4,16 +4,26 @@ import argparse
 import textwrap
 import urllib.request
 
+def str2bool(value):
+    if value.lower() == 'true':
+        return True
+    elif value.lower() == 'false':
+        return False
+    else:
+        raise argparse.ArgumentTypeError('Boolean value expected.')
+
 parser = argparse.ArgumentParser(prog='owocr', description=textwrap.dedent('''\
     Runs OCR in the background.
     It can read images copied to the system clipboard or placed in a directory, images sent via a websocket or a Unix domain socket, or directly capture a screen (or a portion of it) or a window.
-    Recognized texts can be either saved to system clipboard, appended to a text file or sent via a websocket.
+    Recognized text can be either saved to system clipboard, appended to a text file or sent via a websocket.
 '''))
 
 parser.add_argument('-r', '--read_from', type=str, default=argparse.SUPPRESS,
-                    help='Specifies where to read input images from. Can be either "clipboard", "websocket", "unixsocket" (on macOS/Linux), "screencapture", or a path to a directory.')
+                    help='Where to read input images from. Can be either "clipboard", "websocket", "unixsocket" (on macOS/Linux), "screencapture", or a path to a directory.')
+parser.add_argument('-rs', '--read_from_secondary', type=str, default=argparse.SUPPRESS,
+                    help="Optional secondary source to read input images from. Same options as read_from, but they can't both be directory paths.")
 parser.add_argument('-w', '--write_to', type=str, default=argparse.SUPPRESS,
-                    help='Specifies where to save recognized texts to. Can be either "clipboard", "websocket", or a path to a text file.')
+                    help='Where to save recognized texts to. Can be either "clipboard", "websocket", or a path to a text file.')
 parser.add_argument('-e', '--engine', type=str, default=argparse.SUPPRESS,
                     help='OCR engine to use. Available: "mangaocr", "glens", "glensweb", "bing", "gvision", "avision", "alivetext", "azure", "winrtocr", "oneocr", "easyocr", "rapidocr", "ocrspace".')
 parser.add_argument('-p', '--pause_at_startup', action='store_true', default=argparse.SUPPRESS,
@@ -23,21 +33,21 @@ parser.add_argument('-i', '--ignore_flag', action='store_true', default=argparse
 parser.add_argument('-d', '--delete_images', action='store_true', default=argparse.SUPPRESS,
                     help='Delete image files after processing when reading from a directory.')
 parser.add_argument('-n', '--notifications', action='store_true', default=argparse.SUPPRESS,
-                    help='Show an operating system notification with the detected text.')
+                    help='Show an operating system notification with the detected text. Will be ignored when reading with screen capture, unless screen_capture_combo is set.')
 parser.add_argument('-a', '--auto_pause', type=float, default=argparse.SUPPRESS,
-                    help='Automatically pause the program after the specified amount of seconds since the last successful text recognition. Will be ignored when reading with screen capture. 0 to disable.')
+                    help='Automatically pause the program after the specified amount of seconds since the last successful text recognition. Will be ignored when reading with screen capture, unless screen_capture_combo is set. 0 to disable.')
 parser.add_argument('-cp', '--combo_pause', type=str, default=argparse.SUPPRESS,
-                    help='Specifies a combo to wait on for pausing the program. As an example: "<ctrl>+<shift>+p". The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key')
+                    help='Combo to wait on for pausing the program. As an example: "<ctrl>+<shift>+p". The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key')
 parser.add_argument('-cs', '--combo_engine_switch', type=str, default=argparse.SUPPRESS,
-                    help='Specifies a combo to wait on for switching the OCR engine. As an example: "<ctrl>+<shift>+a". To be used with combo_pause. The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key')
+                    help='Combo to wait on for switching the OCR engine. As an example: "<ctrl>+<shift>+a". To be used with combo_pause. The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key')
 parser.add_argument('-sa', '--screen_capture_area', type=str, default=argparse.SUPPRESS,
-                    help='Specifies area to target when reading with screen capture. Can be either empty (automatic selector), a set of coordinates (x,y,width,height), "screen_N" (captures a whole screen, where N is the screen number starting from 1) or a window name (the first matching window title will be used).')
+                    help='Area to target when reading with screen capture. Can be either empty (automatic selector), a set of coordinates (x,y,width,height), "screen_N" (captures a whole screen, where N is the screen number starting from 1) or a window name (the first matching window title will be used).')
 parser.add_argument('-sd', '--screen_capture_delay_secs', type=float, default=argparse.SUPPRESS,
-                    help='Specifies the delay (in seconds) between screenshots when reading with screen capture.')
-parser.add_argument('-sw', '--screen_capture_only_active_windows', action='store_true', default=argparse.SUPPRESS,
-                    help="When reading with screen capture and screen_capture_area is a window name, specifies whether to only target the window while it's active.")
+                    help='Delay (in seconds) between screenshots when reading with screen capture.')
+parser.add_argument('-sw', '--screen_capture_only_active_windows', type=str2bool, default=argparse.SUPPRESS,
+                    help="When reading with screen capture and screen_capture_area is a window name, only target the window while it's active.")
 parser.add_argument('-sc', '--screen_capture_combo', type=str, default=argparse.SUPPRESS,
-                    help='When reading with screen capture, specifies a combo to wait on for taking a screenshot instead of using the delay. As an example: "<ctrl>+<shift>+s". The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key')
+                    help='When reading with screen capture, combo to wait on for taking a screenshot instead of using the delay. As an example: "<ctrl>+<shift>+s". The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key')
 
 class Config:
     has_config = False
@@ -47,6 +57,7 @@ class Config:
     __engine_config = {}
     __default_config = {
         'read_from': 'clipboard',
+        'read_from_secondary': '',
         'write_to': 'clipboard',
         'engine': '',
         'pause_at_startup': False,
@@ -64,7 +75,8 @@ class Config:
         'screen_capture_area': '',
         'screen_capture_delay_secs': 3,
         'screen_capture_only_active_windows': True,
-        'screen_capture_combo': ''
+        'screen_capture_combo': '',
+        'screen_capture_old_macos_api': False
     }
 
     def __parse(self, value):