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

GameSentenceMiner/util/model.py

@@ -0,0 +1,177 @@
+from dataclasses import dataclass
+from typing import Optional, List
+
+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 AnkiCard:
+    noteId: int
+    tags: list[str]
+    fields: dict[str, dict[str, str]]
+    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

GameSentenceMiner/util/notification.py

@@ -0,0 +1,124 @@
+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:
+        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 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):
+    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
+        )
+
+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
+    )
+
+

GameSentenceMiner/util/package.py

@@ -0,0 +1,37 @@
+from importlib import metadata
+
+import requests
+
+from GameSentenceMiner.util.configuration import logger
+
+PACKAGE_NAME = "GameSentenceMiner"
+
+def get_current_version():
+    try:
+        version = metadata.version(PACKAGE_NAME)
+        return version
+    except metadata.PackageNotFoundError:
+        return None
+
+def get_latest_version():
+    try:
+        response = requests.get(f"https://pypi.org/pypi/{PACKAGE_NAME}/json")
+        latest_version = response.json()["info"]["version"]
+        return latest_version
+    except Exception as e:
+        logger.error(f"Error fetching latest version: {e}")
+        return None
+
+def check_for_updates(force=False):
+    try:
+        installed_version = get_current_version()
+        latest_version = get_latest_version()
+
+        if installed_version != latest_version or force:
+            logger.info(f"Update available: {installed_version} -> {latest_version}")
+            return True, latest_version
+        else:
+            logger.info("You are already using the latest version.")
+            return False, latest_version
+    except Exception as e:
+        logger.error(f"Error checking for updates: {e}")

GameSentenceMiner/util/ss_selector.py

@@ -0,0 +1,122 @@
+import tkinter as tk
+from PIL import Image, ImageTk
+import subprocess
+import os
+import sys
+
+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 = []
+    timestamp_number = float(timestamp)
+    golden_frame_index = 1  # Default to the first frame
+    golden_frame = None
+    video_duration = ffmpeg.get_video_duration(video_path)
+
+    if mode == 'middle':
+        timestamp_number = max(0.0, timestamp_number - 2.5)
+    elif mode == 'end':
+        timestamp_number = max(0.0, timestamp_number - 5.0)
+
+    if video_duration is not None and timestamp_number > video_duration:
+        logger.debug(f"Timestamp {timestamp_number} exceeds video duration {video_duration}.")
+        return None
+
+    try:
+        command = ffmpeg_base_command_list + [
+            "-y",
+            "-ss", str(timestamp_number),
+            "-i", video_path,
+            "-vf", f"fps=1/{0.25}",
+            "-vframes", "20",
+            os.path.join(temp_dir, "frame_%02d.png")
+        ]
+        subprocess.run(command, check=True, capture_output=True)
+        for i in range(1, 21):
+            if os.path.exists(os.path.join(temp_dir, f"frame_{i:02d}.png")):
+                frame_paths.append(os.path.join(temp_dir, f"frame_{i:02d}.png"))
+
+        if mode == "beginning":
+            golden_frame = frame_paths[0]
+        if mode == "middle":
+            golden_frame = frame_paths[len(frame_paths) // 2]
+        if mode == "end":
+            golden_frame = frame_paths[-1]
+    except subprocess.CalledProcessError as e:
+        logger.debug(f"Error extracting frames: {e}")
+        logger.debug(f"Command was: {' '.join(command)}")
+        logger.debug(f"FFmpeg output:\n{e.stderr.decode()}")
+        return None
+    except Exception as e:
+        logger.debug(f"An error occurred: {e}")
+        return None
+    return frame_paths, golden_frame
+
+def timestamp_to_seconds(timestamp):
+    hours, minutes, seconds = map(int, timestamp.split(':'))
+    return hours * 3600 + minutes * 60 + seconds
+
+def display_images(image_paths, golden_frame):
+    window = tk.Tk()
+    window.configure(bg="black")  # Set the background color to black
+    window.title("Image Selector")
+    selected_path = tk.StringVar()
+    image_widgets = []
+
+    def on_image_click(event):
+        widget = event.widget
+        index = image_widgets.index(widget)
+        selected_path.set(image_paths[index])
+        window.quit()
+
+    for i, path in enumerate(image_paths):
+        img = Image.open(path)
+        img.thumbnail((450, 450))
+        img_tk = ImageTk.PhotoImage(img)
+        if golden_frame and path == golden_frame:
+            label = tk.Label(window, image=img_tk, borderwidth=5, relief="solid")
+            label.config(highlightbackground="yellow", highlightthickness=5)
+        else:
+            label = tk.Label(window, image=img_tk)
+        label.image = img_tk
+        label.grid(row=i // 5, column=i % 5, padx=5, pady=5)
+        label.bind("<Button-1>", on_image_click)  # Bind click event to the label
+        image_widgets.append(label)
+
+    window.attributes("-topmost", True)
+    window.mainloop()
+    return selected_path.get()
+
+def run_extraction_and_display(video_path, timestamp_str, mode):
+    temp_dir = os.path.join(get_temporary_directory(False), "screenshot_frames", sanitize_filename(os.path.splitext(os.path.basename(video_path))[0]))
+    os.makedirs(temp_dir, exist_ok=True)
+    image_paths, golden_frame = extract_frames(video_path, timestamp_str, temp_dir, mode)
+    if image_paths:
+        selected_image_path = display_images(image_paths, golden_frame)
+        if selected_image_path:
+            print(selected_image_path)
+        else:
+            logger.debug("No image was selected.")
+    else:
+        logger.debug("Frame extraction failed.")
+
+def main():
+    # if len(sys.argv) != 3:
+    #     print("Usage: python script.py <video_path> <timestamp>")
+    #     sys.exit(1)
+    try:
+        video_path = sys.argv[1]
+        timestamp_str = sys.argv[2]
+        mode = sys.argv[3] if len(sys.argv) > 3 else "beginning"
+        run_extraction_and_display(video_path, timestamp_str, mode)
+    except Exception as e:
+        logger.debug(e)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

GameSentenceMiner/util/text_log.py

@@ -0,0 +1,186 @@
+import uuid
+from dataclasses import dataclass
+from datetime import datetime
+from difflib import SequenceMatcher
+from typing import Optional
+
+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()
+
+
+@dataclass
+class GameLine:
+    id: str
+    text: str
+    time: datetime
+    prev: 'GameLine | None'
+    next: 'GameLine | None'
+    index: int = 0
+
+    def get_previous_time(self):
+        if self.prev:
+            return self.prev.time
+        return initial_time
+
+    def get_next_time(self):
+        if self.next:
+            return self.next.time
+        return 0
+
+    def __str__(self):
+        return str({"text": self.text, "time": self.time})
+
+
+@dataclass
+class GameText:
+    values: list[GameLine]
+    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 if line_time else datetime.now(),
+            prev=self.values[-1] if self.values else None,
+            next=None,
+            index=self.game_line_index
+        )
+        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
+
+
+text_log = GameText()
+
+
+def similar(a, b):
+    return SequenceMatcher(None, a, b).ratio()
+
+
+def one_contains_the_other(a, b):
+    return a in b or b in a
+
+
+def lines_match(a, b):
+    similarity = similar(a, b)
+    logger.debug(f"Comparing: {a} with {b} - Similarity: {similarity}, Or One contains the other: {one_contains_the_other(a, b)}")
+    return similar(a, b) >= 0.60 or one_contains_the_other(a, b)
+
+
+def get_text_event(last_note) -> GameLine:
+    lines = text_log.values
+
+    if not lines:
+        raise Exception("No lines in history. Text is required from either clipboard or websocket for GSM to work. Please check your setup/config.")
+
+    if not last_note:
+        return lines[-1]
+
+    sentence = last_note.get_field(get_config().anki.sentence_field)
+    if not sentence:
+        return lines[-1]
+
+    for line in reversed(lines):
+        if lines_match(line.text, remove_html_and_cloze_tags(sentence)):
+            return line
+
+    logger.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 text_log.values:
+            if found:
+                found_lines.append(line.text)
+            if lines_match(line.text, remove_html_and_cloze_tags(sentence)):  # 80% similarity threshold
+                found = True
+                found_lines.append(line.text)
+    return found_lines
+
+
+def get_mined_line(last_note: AnkiCard, lines):
+    if not last_note:
+        return lines[-1]
+    if not lines:
+        lines = get_all_lines()
+
+    sentence = last_note.get_field(get_config().anki.sentence_field)
+    for line in lines:
+        if lines_match(line.text, remove_html_and_cloze_tags(sentence)):
+            return line
+    return lines[-1]
+
+
+def get_time_of_line(line):
+    return text_log.get_time(line)
+
+
+def get_all_lines():
+    return text_log.values
+
+
+def get_text_log() -> GameText:
+    return text_log
+
+def add_line(current_line_after_regex, line_time):
+    text_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 text_log.get_by_id(line_id)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.9.5
+Version: 2.9.7
 Summary: A tool for mining sentences from games.
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License