GameSentenceMiner 2.0.0__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -0,0 +1,265 @@
+import base64
+import subprocess
+import threading
+import time
+import urllib.request
+
+import requests as req
+
+from . import util
+from . import ffmpeg
+from . import notification
+from . import obs
+
+from .configuration import *
+from .configuration import get_config
+from .gametext import get_last_two_sentences
+from .obs import get_current_game
+
+audio_in_anki = None
+screenshot_in_anki = None
+
+# Global variables to track state
+previous_note_ids = set()
+first_run = True
+
+
+def update_anki_card(last_note, note=None, audio_path='', video_path='', tango='', reuse_audio=False,
+                     should_update_audio=True, ss_time=0):
+    global audio_in_anki, screenshot_in_anki
+    update_audio = should_update_audio and (get_config().anki.sentence_audio_field and not
+    last_note['fields'][get_config().anki.sentence_audio_field][
+        'value'] or get_config().anki.overwrite_audio)
+    update_picture = (get_config().anki.picture_field and get_config().anki.overwrite_picture) or not \
+    last_note['fields'][get_config().anki.picture_field][
+        'value']
+
+    if not reuse_audio:
+        if update_audio:
+            audio_in_anki = store_media_file(audio_path)
+        if update_picture:
+            screenshot = ffmpeg.get_screenshot(video_path, ss_time)
+            screenshot_in_anki = store_media_file(screenshot)
+            if get_config().paths.remove_screenshot:
+                os.remove(screenshot)
+    audio_html = f"[sound:{audio_in_anki}]"
+    image_html = f"<img src=\"{screenshot_in_anki}\">"
+
+    # note = {'id': last_note['noteId'], 'fields': {}}
+
+    if update_audio:
+        note['fields'][get_config().anki.sentence_audio_field] = audio_html
+
+    if update_picture:
+        note['fields'][get_config().anki.picture_field] = image_html
+
+    if get_config().anki.anki_custom_fields:
+        for key, value in get_config().anki.anki_custom_fields.items():
+            note['fields'][key] = str(value)
+
+    invoke("updateNoteFields", note=note)
+    tags = []
+    if get_config().anki.custom_tags:
+        tags.extend(get_config().anki.custom_tags)
+    if get_config().anki.add_game_tag:
+        tags.append(get_current_game().replace(" ", ""))
+    if tags:
+        tag_string = " ".join(tags)
+        invoke("addTags", tags=tag_string, notes=[last_note['noteId']])
+    logger.info(f"UPDATED ANKI CARD FOR {last_note['noteId']}")
+    if get_config().features.notify_on_update:
+        notification.send_notification(tango)
+    if get_config().features.open_anki_edit:
+        notification.open_anki_card(last_note['noteId'])
+
+    if get_config().audio.external_tool:
+        open_audio_in_external(f"{get_config().audio.anki_media_collection}/{audio_in_anki}")
+
+
+def open_audio_in_external(fileabspath, shell=False):
+    logger.info(f"Opening audio: {fileabspath} in external Program: {get_config().audio.external_tool}")
+    if shell:
+        subprocess.Popen(f' "{get_config().audio.external_tool}" "{fileabspath}" ', shell=True)
+    else:
+        subprocess.Popen([get_config().audio.external_tool, fileabspath])
+
+
+def add_image_to_card(last_note, image_path):
+    global screenshot_in_anki
+    update_picture = get_config().anki.overwrite_picture or not last_note['fields'][get_config().anki.picture_field][
+        'value']
+
+    if update_picture:
+        screenshot_in_anki = store_media_file(image_path)
+        if get_config().paths.remove_screenshot:
+            os.remove(image_path)
+
+    image_html = f"<img src=\"{screenshot_in_anki}\">"
+
+    note = {'id': last_note['noteId'], 'fields': {}}
+
+    if update_picture:
+        note['fields'][get_config().anki.picture_field] = image_html
+
+    invoke("updateNoteFields", note=note)
+
+    logger.info(f"UPDATED IMAGE FOR ANKI CARD {last_note['noteId']}")
+
+
+def get_initial_card_info(last_note):
+    note = {'id': last_note['noteId'], 'fields': {}}
+    if not last_note:
+        return note
+    current_line, previous_line = get_last_two_sentences()
+    logger.debug(f"Previous Sentence {previous_line}")
+    logger.debug(f"Current Sentence {current_line}")
+    util.use_previous_audio = True
+
+    logger.debug(
+        f"Adding Previous Sentence: {get_config().anki.previous_sentence_field and previous_line and not last_note['fields'][get_config().anki.previous_sentence_field]['value']}")
+    if get_config().anki.previous_sentence_field and previous_line and not \
+            last_note['fields'][get_config().anki.previous_sentence_field]['value']:
+        note['fields'][get_config().anki.previous_sentence_field] = previous_line
+    return note
+
+
+def store_media_file(path):
+    return invoke('storeMediaFile', filename=path, data=convert_to_base64(path))
+
+
+def convert_to_base64(file_path):
+    with open(file_path, "rb") as file:
+        file_base64 = base64.b64encode(file.read()).decode('utf-8')
+    return file_base64
+
+
+def request(action, **params):
+    return {'action': action, 'params': params, 'version': 6}
+
+
+def invoke(action, **params):
+    request_json = json.dumps(request(action, **params)).encode('utf-8')
+    # if action != "storeMediaFile":
+    #     logger.debug(f"Hitting Anki. Action: {action}. Data: {request_json}")
+    response = json.load(urllib.request.urlopen(urllib.request.Request(get_config().anki.url, request_json)))
+    if len(response) != 2:
+        raise Exception('response has an unexpected number of fields')
+    if 'error' not in response:
+        raise Exception('response is missing required error field')
+    if 'result' not in response:
+        raise Exception('response is missing required result field')
+    if response['error'] is not None:
+        raise Exception(response['error'])
+    return response['result']
+
+
+def get_last_anki_card():
+    added_ids = invoke('findNotes', query='added:1')
+    if not added_ids:
+        return {}
+    last_note = invoke('notesInfo', notes=[added_ids[-1]])[0]
+    return last_note
+
+
+def add_wildcards(expression):
+    return '*' + '*'.join(expression) + '*'
+
+
+def get_cards_by_sentence(sentence):
+    sentence = sentence.replace(" ", "")
+    query = f'{get_config().anki.sentence_audio_field}: {get_config().anki.sentence_field}:{add_wildcards(sentence)}'
+    card_ids = invoke("findCards", query=query)
+
+    if not card_ids:
+        print(f"Didn't find any cards matching query:\n{query}")
+        return {}
+    if len(card_ids) > 1:
+        print(f'Found more than 1, and not updating cards for query: \n{query}')
+        return {}
+
+    last_notes = invoke('notesInfo', notes=[card_ids[0]])[0]
+
+    print(f"Found Card to backfill!: {card_ids[0]}")
+
+    return last_notes
+
+
+# Check for new Anki cards and save replay buffer if detected
+def check_for_new_cards():
+    global previous_note_ids, first_run
+    current_note_ids = set()
+    try:
+        current_note_ids = get_note_ids()
+    except Exception as e:
+        print(f"Error fetching Anki notes: {e}")
+        return
+    new_card_ids = current_note_ids - previous_note_ids
+    if new_card_ids and not first_run:
+        update_new_card()
+    first_run = False
+    previous_note_ids = current_note_ids  # Update the list of known notes
+
+
+def update_new_card():
+    last_card = get_last_anki_card()
+    if not check_tags_for_should_update(last_card):
+        logger.info("Card not tagged properly! Not updating!")
+        return
+
+    use_prev_audio = util.use_previous_audio
+    if util.lock.locked():
+        print("Audio still being Trimmed, Card Queued!")
+        use_prev_audio = True
+    with util.lock:
+        print(f"use previous audio: {use_prev_audio}")
+        if get_config().obs.get_game_from_scene:
+            obs.update_current_game()
+        if use_prev_audio:
+            update_anki_card(last_card, note=get_initial_card_info(last_card), reuse_audio=True)
+        else:
+            print("New card(s) detected!")
+            obs.save_replay_buffer()
+
+
+def check_tags_for_should_update(last_card):
+    if get_config().anki.tags_to_check:
+        found = False
+        for tag in last_card['tags']:
+            logger.info(tag)
+            logger.info(get_config().anki.tags_to_check)
+            if tag.lower() in get_config().anki.tags_to_check:
+                found = True
+                break
+        return found
+    else:
+        return True
+
+
+# Main function to handle the script lifecycle
+def monitor_anki():
+    try:
+        # Continuously check for new cards
+        while True:
+            check_for_new_cards()
+            time.sleep(get_config().anki.polling_rate / 1000.0)  # Check every 200ms
+    except KeyboardInterrupt:
+        print("Stopped Checking For Anki Cards...")
+
+
+# Fetch recent note IDs from Anki
+def get_note_ids():
+    response = req.post(get_config().anki.url, json={
+        "action": "findNotes",
+        "version": 6,
+        "params": {"query": "added:1"}
+    })
+    result = response.json()
+    return set(result['result'])
+
+
+def start_monitoring_anki():
+    # Start monitoring anki
+    if get_config().obs.enabled and get_config().features.full_auto:
+        obs_thread = threading.Thread(target=monitor_anki)
+        obs_thread.daemon = True  # Ensures the thread will exit when the main program exits
+        obs_thread.start()