GameSentenceMiner 2.14.8__py3-none-any.whl → 2.14.9__py3-none-any.whl

GameSentenceMiner/util/model.py

@@ -1,206 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional, List
-from enum import Enum
-
-from dataclasses_json import dataclass_json
-
-from GameSentenceMiner.util.configuration import get_config, logger, save_current_config
-
-
-# OBS
-@dataclass_json
-@dataclass
-class SceneInfo:
-    currentProgramSceneName: str
-    currentProgramSceneUuid: str
-    sceneName: str
-    sceneUuid: str
-
-
-@dataclass_json
-@dataclass
-class SceneItemTransform:
-    alignment: int
-    boundsAlignment: int
-    boundsHeight: float
-    boundsType: str
-    boundsWidth: float
-    cropBottom: int
-    cropLeft: int
-    cropRight: int
-    cropToBounds: bool
-    cropTop: int
-    height: float
-    positionX: float
-    positionY: float
-    rotation: float
-    scaleX: float
-    scaleY: float
-    sourceHeight: float
-    sourceWidth: float
-    width: float
-
-
-@dataclass_json
-@dataclass
-class SceneItem:
-    inputKind: str
-    isGroup: Optional[bool]
-    sceneItemBlendMode: str
-    sceneItemEnabled: bool
-    sceneItemId: int
-    sceneItemIndex: int
-    sceneItemLocked: bool
-    sceneItemTransform: SceneItemTransform
-    sourceName: str
-    sourceType: str
-    sourceUuid: str
-
-    # def __init__(self, **kwargs):
-    #     self.inputKind = kwargs['inputKind']
-    #     self.isGroup = kwargs['isGroup']
-    #     self.sceneItemBlendMode = kwargs['sceneItemBlendMode']
-    #     self.sceneItemEnabled = kwargs['sceneItemEnabled']
-    #     self.sceneItemId = kwargs['sceneItemId']
-    #     self.sceneItemIndex = kwargs['sceneItemIndex']
-    #     self.sceneItemLocked = kwargs['sceneItemLocked']
-    #     self.sceneItemTransform = SceneItemTransform(**kwargs['sceneItemTransform'])
-    #     self.sourceName = kwargs['sourceName']
-    #     self.sourceType = kwargs['sourceType']
-    #     self.sourceUuid = kwargs['sourceUuid']
-
-
-@dataclass_json
-@dataclass
-class SceneItemsResponse:
-    sceneItems: List[SceneItem]
-
-    # def __init__(self, **kwargs):
-    #     self.sceneItems = [SceneItem(**item) for item in kwargs['sceneItems']]
-
-
-@dataclass_json
-@dataclass
-class RecordDirectory:
-    recordDirectory: str
-
-
-@dataclass_json
-@dataclass
-class SceneItemInfo:
-    sceneIndex: int
-    sceneName: str
-    sceneUuid: str
-
-
-@dataclass_json
-@dataclass
-class SceneListResponse:
-    scenes: List[SceneItemInfo]
-    currentProgramSceneName: Optional[str] = None
-    currentProgramSceneUuid: Optional[str] = None
-    currentPreviewSceneName: Optional[str] = None
-    currentPreviewSceneUuid: Optional[str] = None
-
-#
-# @dataclass_json
-# @dataclass
-# class SourceActive:
-#     videoActive: bool
-#     videoShowing: bool
-
-@dataclass_json
-@dataclass
-class AnkiField:
-    value: str
-    order: int
-
-@dataclass_json
-@dataclass
-class AnkiCard:
-    noteId: int
-    tags: list[str]
-    fields: dict[str, AnkiField]
-    cards: list[int]
-    alternatives = {
-        "word_field": ["Front", "Word", "TargetWord", "Expression"],
-        "sentence_field": ["Example", "Context", "Back", "Sentence"],
-        "picture_field": ["Image", "Visual", "Media", "Picture", "Screenshot", 'AnswerImage'],
-        "sentence_audio_field": ["SentenceAudio"]
-    }
-
-    def get_field(self, field_name: str) -> str:
-        if self.has_field(field_name):
-            return self.fields[field_name].value
-        else:
-            raise ValueError(f"Field '{field_name}' not found in AnkiCard. Please make sure your Anki Field Settings in GSM Match your fields in your Anki Note!")
-
-    def has_field (self, field_name: str) -> bool:
-        return field_name in self.fields
-
-    def __post_init__(self):
-        config = get_config()
-        changes_found = False
-        if not self.has_field(config.anki.word_field):
-            found_alternative_field, field = self.find_field(config.anki.word_field, "word_field")
-            if found_alternative_field:
-                logger.warning(f"{config.anki.word_field} Not found in Anki Card! Saving alternative field '{field}' for word_field to settings.")
-                config.anki.word_field = field
-                changes_found = True
-
-        if not self.has_field(config.anki.sentence_field):
-            found_alternative_field, field = self.find_field(config.anki.sentence_field, "sentence_field")
-            if found_alternative_field:
-                logger.warning(f"{config.anki.sentence_field} Not found in Anki Card! Saving alternative field '{field}' for sentence_field to settings.")
-                config.anki.sentence_field = field
-                changes_found = True
-
-        if not self.has_field(config.anki.picture_field):
-            found_alternative_field, field = self.find_field(config.anki.picture_field, "picture_field")
-            if found_alternative_field:
-                logger.warning(f"{config.anki.picture_field} Not found in Anki Card! Saving alternative field '{field}' for picture_field to settings.")
-                config.anki.picture_field = field
-                changes_found = True
-
-        if not self.has_field(config.anki.sentence_audio_field):
-            found_alternative_field, field = self.find_field(config.anki.sentence_audio_field, "sentence_audio_field")
-            if found_alternative_field:
-                logger.warning(f"{config.anki.sentence_audio_field} Not found in Anki Card! Saving alternative field '{field}' for sentence_audio_field to settings.")
-                config.anki.sentence_audio_field = field
-                changes_found = True
-
-        if changes_found:
-            save_current_config(config)
-
-    def find_field(self, field, field_type):
-        if field in self.fields:
-            return False, field
-
-        for alt_field in self.alternatives[field_type]:
-            for key in self.fields:
-                if alt_field.lower() == key.lower():
-                    return True, key
-
-        return False, None
-
-
-class VADResult:
-    def __init__(self, success: bool, start: float, end: float, model: str, segments: list = None, output_audio: str = None):
-        self.success = success
-        self.start = start
-        self.end = end
-        self.model = model
-        self.segments = segments if segments is not None else []
-        self.output_audio = output_audio
-
-    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}."

GameSentenceMiner/util/notification.py

@@ -1,147 +0,0 @@
-import requests
-from plyer import notification
-from GameSentenceMiner.util.configuration import logger, is_windows
-
-if is_windows():
-    from win10toast import ToastNotifier
-
-if is_windows():
-    class MyToastNotifier(ToastNotifier):
-        def __init__(self):
-            super().__init__()
-
-        def on_destroy(self, hwnd, msg, wparam, lparam):
-            super().on_destroy(hwnd, msg, wparam, lparam)
-            return 0
-
-if is_windows():
-    notifier = MyToastNotifier()
-else:
-    notifier = notification
-
-
-def open_browser_window(note_id, query=None):
-    url = "http://localhost:8765"
-    headers = {'Content-Type': 'application/json'}
-
-    data = {
-        "action": "guiBrowse",
-        "version": 6,
-        "params": {
-            "query": f"nid:{note_id}" if not query else query,
-        }
-    }
-
-    try:
-        if query:
-            blank_req_data = {
-                "action": "guiBrowse",
-                "version": 6,
-                "params": {
-                    "query": "nid:1",
-                }
-            }
-            requests.post(url, json=blank_req_data, headers=headers)
-        response = requests.post(url, json=data, headers=headers)
-        if response.status_code == 200:
-            if query:
-                logger.info(f"Opened Anki browser with query: {query}")
-            else:
-                logger.info(f"Opened Anki note in browser with ID {note_id}")
-        else:
-            logger.error(f"Failed to open Anki note with ID {note_id}")
-    except Exception as e:
-        logger.info(f"Error connecting to AnkiConnect: {e}")
-
-
-def open_anki_card(note_id):
-    url = "http://localhost:8765"
-    headers = {'Content-Type': 'application/json'}
-
-    data = {
-        "action": "guiEditNote",
-        "version": 6,
-        "params": {
-            "note": note_id
-        }
-    }
-
-    try:
-        response = requests.post(url, json=data, headers=headers)
-        if response.status_code == 200:
-            logger.info(f"Opened Anki note with ID {note_id}")
-        else:
-            logger.error(f"Failed to open Anki note with ID {note_id}")
-    except Exception as e:
-        logger.info(f"Error connecting to AnkiConnect: {e}")
-
-
-def send_notification(title, message, timeout):
-    try:
-        if is_windows():
-            notifier.show_toast(
-                title, message, duration=timeout, threaded=True)
-        else:
-            notification.notify(
-                title=title,
-                message=message,
-                app_name="GameSentenceMiner",
-                timeout=timeout  # Notification disappears after 5 seconds
-            )
-    except Exception as e:
-        logger.error(f"Failed to send notification: {e}")
-
-
-def send_note_updated(tango):
-    send_notification(
-        title="Anki Card Updated",
-        message=f"Audio and/or Screenshot added to note: {tango}",
-        timeout=5  # Notification disappears after 5 seconds
-    )
-
-
-def send_screenshot_updated(tango):
-    send_notification(
-        title="Anki Card Updated",
-        message=f"Screenshot updated on note: {tango}",
-        timeout=5  # Notification disappears after 5 seconds
-    )
-
-
-def send_screenshot_saved(path):
-    send_notification(
-        title="Screenshot Saved",
-        message=f"Screenshot saved to : {path}",
-        timeout=5  # Notification disappears after 5 seconds
-    )
-
-
-def send_audio_generated_notification(audio_path):
-    send_notification(
-        title="Audio Trimmed",
-        message=f"Audio Trimmed and placed at {audio_path}",
-        timeout=5  # Notification disappears after 5 seconds
-    )
-
-
-def send_check_obs_notification(reason):
-    send_notification(
-        title="OBS Replay Invalid",
-        message=f"Check OBS Settings! Reason: {reason}",
-        timeout=5  # Notification disappears after 5 seconds
-    )
-
-
-def send_error_no_anki_update():
-    send_notification(
-        title="Error",
-        message=f"Anki Card not updated, Check Console for Reason!",
-        timeout=5  # Notification disappears after 5 seconds
-    )
-    
-def send_error_notification(message):
-    send_notification(
-        title="Error",
-        message=message,
-        timeout=5  # Notification disappears after 5 seconds
-    )

GameSentenceMiner/util/text_log.py

@@ -1,214 +0,0 @@
-import uuid
-from dataclasses import dataclass
-from datetime import datetime
-from difflib import SequenceMatcher
-from typing import Optional
-
-import rapidfuzz
-
-from GameSentenceMiner.util.gsm_utils import remove_html_and_cloze_tags
-from GameSentenceMiner.util.configuration import logger, get_config, gsm_state
-from GameSentenceMiner.util.model import AnkiCard
-import re
-
-initial_time = datetime.now()
-
-
-@dataclass
-class GameLine:
-    id: str
-    text: str
-    time: datetime
-    prev: 'GameLine | None'
-    next: 'GameLine | None'
-    index: int = 0
-    scene: str = ""
-    TL: str = ""
-
-    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 set_TL(self, tl: str):
-        self.TL = tl
-
-    def get_stripped_text(self):
-        return self.text.replace('\n', '').strip()
-
-    def __str__(self):
-        return str({"text": self.text, "time": self.time})
-
-
-@dataclass
-class GameText:
-    values: list[GameLine]
-    values_dict: dict[str, GameLine]
-    game_line_index = 0
-
-    def __init__(self):
-        self.values = []
-        self.values_dict = {}
-
-    def __getitem__(self, index):
-        return self.values[index]
-
-    def get_by_id(self, line_id: str) -> Optional[GameLine]:
-        if not self.values_dict:
-            return None
-        return self.values_dict.get(line_id)
-
-    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
-        line_id = str(uuid.uuid1())
-        new_line = GameLine(
-            id=line_id,  # Time-based UUID as an integer
-            text=line_text,
-            time=line_time or datetime.now(),
-            prev=self.values[-1] if self.values else None,
-            next=None,
-            index=self.game_line_index,
-            scene=gsm_state.current_game or ""
-        )
-        self.values_dict[line_id] = new_line
-        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 get_last_line(self):
-        if self.values:
-            return self.values[-1]
-        return None
-
-
-game_log = GameText()
-
-def strip_whitespace_and_punctuation(text: str) -> str:
-    """
-    Strips whitespace and punctuation from the given text.
-    """
-    # Remove all whitespace and specified punctuation using regex
-    # Includes Japanese and common punctuation
-    return re.sub(r'[\s　、。「」【】《》., ]', '', text).strip()
-
-
-def lines_match(texthooker_sentence, anki_sentence):
-    # Replace newlines, spaces, other whitespace characters, AND japanese punctuation
-    texthooker_sentence = strip_whitespace_and_punctuation(texthooker_sentence)
-    anki_sentence = strip_whitespace_and_punctuation(anki_sentence)
-    similarity = rapidfuzz.fuzz.ratio(texthooker_sentence, anki_sentence)
-    logger.debug(f"Comparing sentences: '{texthooker_sentence}' and '{anki_sentence}' - Similarity: {similarity}")
-    if texthooker_sentence in anki_sentence:
-        logger.debug(f"One contains the other: {texthooker_sentence} in {anki_sentence} - Similarity: {similarity}")
-    elif anki_sentence in texthooker_sentence:
-        logger.debug(f"One contains the other: {anki_sentence} in {texthooker_sentence} - Similarity: {similarity}")
-    return (anki_sentence in texthooker_sentence) or (texthooker_sentence in anki_sentence) or (similarity >= 80)
-
-
-def get_text_event(last_note) -> GameLine:
-    lines = game_log.values
-
-    if not lines:
-        raise Exception("No voicelines in GSM. GSM can only do work on text that has been sent to it since it started. If you are not getting any text into GSM, 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.info("Could not find matching sentence from GSM's history. Using the latest line.")
-    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 game_log.values:
-            if found:
-                found_lines.append(line)
-            if lines_match(line.text, remove_html_and_cloze_tags(sentence)):  # 80% similarity threshold
-                found = True
-                found_lines.append(line)
-    return found_lines
-
-
-def get_mined_line(last_note: AnkiCard, lines=None):
-    if lines is None:
-        lines = []
-    if not last_note:
-        return lines[-1]
-    if not lines:
-        lines = get_all_lines()
-    if not lines:
-        raise Exception("No voicelines in GSM. GSM can only do work on text that has been sent to it since it started. If you are not getting any text into GSM, please check your setup/config.")
-
-    sentence = last_note.get_field(get_config().anki.sentence_field)
-    for line in reversed(lines):
-        if lines_match(line.get_stripped_text(), remove_html_and_cloze_tags(sentence)):
-            return line
-    return lines[-1]
-
-
-def get_time_of_line(line):
-    return game_log.get_time(line)
-
-
-def get_all_lines():
-    return game_log.values
-
-
-def get_text_log() -> GameText:
-    return game_log
-
-def add_line(current_line_after_regex, line_time):
-    game_log.add_line(current_line_after_regex, line_time)
-
-def get_line_by_id(line_id: str) -> Optional[GameLine]:
-    """
-    Retrieve a GameLine by its unique ID.
-
-    Args:
-        line_id (str): The unique identifier of the GameLine.
-
-    Returns:
-        Optional[GameLine]: The GameLine object if found, otherwise None.
-    """
-    return game_log.get_by_id(line_id)

GameSentenceMiner/web/service.py

@@ -1,132 +0,0 @@
-import os
-import shutil
-import subprocess
-import threading
-
-
-from GameSentenceMiner import anki
-from GameSentenceMiner.util import ffmpeg, notification
-from GameSentenceMiner.util.configuration import gsm_state, logger, get_config, get_temporary_directory
-from GameSentenceMiner.util.ffmpeg import get_video_timings
-from GameSentenceMiner.util.text_log import GameLine
-
-
-def set_get_audio_from_video_callback(func):
-    global get_audio_from_video
-    get_audio_from_video = func
-
-
-def handle_texthooker_button(video_path=''):
-    try:
-        if gsm_state.line_for_audio:
-            line: GameLine = gsm_state.line_for_audio
-            gsm_state.line_for_audio = None
-            if line == gsm_state.previous_line_for_audio:
-                logger.info("Line is the same as the last one, skipping processing.")
-                if get_config().advanced.audio_player_path:
-                    play_audio_in_external(gsm_state.previous_audio)
-                elif get_config().advanced.video_player_path:
-                    play_video_in_external(line, video_path)
-                else:
-                    import sounddevice as sd
-                    data, samplerate = gsm_state.previous_audio
-                    sd.play(data, samplerate)
-                    sd.wait()
-                return
-            gsm_state.previous_line_for_audio = line
-            if get_config().advanced.audio_player_path:
-                audio = get_audio_from_video(line, line.next.time if line.next else None, video_path,
-                                             temporary=True)
-                play_audio_in_external(audio)
-                gsm_state.previous_audio = audio
-            elif get_config().advanced.video_player_path:
-                play_video_in_external(line, video_path)
-            else:
-                import sounddevice as sd
-                import soundfile as sf
-                audio = get_audio_from_video(line, line.next.time if line.next else None, video_path,
-                                             temporary=True)
-                data, samplerate = sf.read(audio)
-                sd.play(data, samplerate)
-                sd.wait()
-                gsm_state.previous_audio = (data, samplerate)
-            return
-        if gsm_state.line_for_screenshot:
-            line: GameLine = gsm_state.line_for_screenshot
-            gsm_state.line_for_screenshot = None
-            gsm_state.previous_line_for_screenshot = line
-            screenshot = ffmpeg.get_screenshot_for_line(video_path, line, True)
-            if gsm_state.anki_note_for_screenshot:
-                gsm_state.anki_note_for_screenshot = None
-                encoded_image = ffmpeg.process_image(screenshot)
-                if get_config().anki.update_anki and get_config().screenshot.screenshot_hotkey_updates_anki:
-                    last_note = anki.get_last_anki_card()
-                    if last_note:
-                        anki.add_image_to_card(last_note, encoded_image)
-                        notification.send_screenshot_updated(last_note.get_field(get_config().anki.word_field))
-                        if get_config().features.open_anki_edit:
-                            notification.open_anki_card(last_note.noteId)
-                    else:
-                        notification.send_screenshot_saved(encoded_image)
-                else:
-                    notification.send_screenshot_saved(encoded_image)
-            else:
-                os.startfile(screenshot)
-            return
-    except Exception as e:
-        logger.error(f"Error Playing Audio/Video: {e}")
-        logger.debug(f"Error Playing Audio/Video: {e}", exc_info=True)
-        return
-    finally:
-        gsm_state.previous_replay = video_path
-        gsm_state.videos_to_remove.add(video_path)
-
-
-def play_audio_in_external(filepath):
-    exe = get_config().advanced.audio_player_path
-
-    filepath = os.path.normpath(filepath)
-
-    command = [exe, "--no-video", filepath]
-
-    try:
-        subprocess.Popen(command)
-        print(f"Opened {filepath} in {exe}.")
-    except Exception as e:
-        print(f"An error occurred: {e}")
-
-
-def play_video_in_external(line, filepath):
-    command = [get_config().advanced.video_player_path]
-
-    start, _, _, _ = get_video_timings(filepath, line)
-
-    if start:
-        if "vlc" in get_config().advanced.video_player_path:
-            command.extend(["--start-time", convert_to_vlc_seconds(start), '--one-instance'])
-        else:
-            command.extend(["--start", convert_to_vlc_seconds(start)])
-    command.append(os.path.normpath(filepath))
-
-    logger.info(" ".join(command))
-
-
-
-    try:
-        subprocess.Popen(command)
-        logger.info(f"Opened {filepath} in {get_config().advanced.video_player_path}.")
-    except FileNotFoundError:
-        logger.error("VLC not found. Make sure it's installed and in your PATH.")
-    except Exception as e:
-        logger.error(f"An error occurred: {e}")
-
-
-def convert_to_vlc_seconds(time_str):
-    """Converts HH:MM:SS.milliseconds to VLC-compatible seconds."""
-    try:
-        hours, minutes, seconds_ms = time_str.split(":")
-        seconds, milliseconds = seconds_ms.split(".")
-        total_seconds = (int(hours) * 3600) + (int(minutes) * 60) + int(seconds) + (int(milliseconds) / 1000.0)
-        return str(total_seconds)
-    except ValueError:
-        return "Invalid time format"