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

GameSentenceMiner/notification.py

@@ -1,105 +0,0 @@
-import platform
-
-import requests
-from plyer import notification
-from GameSentenceMiner.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_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/package.py

@@ -1,39 +0,0 @@
-import os
-from importlib import metadata
-
-import requests
-
-from GameSentenceMiner.configuration import logger, get_app_directory
-
-PACKAGE_NAME = "GameSentenceMiner"
-VERSION_FILE_PATH = os.path.join(get_app_directory(), 'version.txt')
-
-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/ss_selector.py

@@ -1,121 +0,0 @@
-import tkinter as tk
-from PIL import Image, ImageTk
-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
-
-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/text_log.py

@@ -1,186 +0,0 @@
-import uuid
-from dataclasses import dataclass
-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
-
-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)