# -*- coding: utf-8 -*-
"""
Mochi French & Anki Standalone Web Server
Học từ vựng trên trình duyệt từ mọi thiết bị (PC, Điện thoại, Tablet) qua Wi-Fi LAN hoặc Internet 4G/5G
Không cần mở Anki Desktop, không cần cài AnkiDroid.
"""
import os
import sys
import re
import html
import json
import time
import shutil
import socket
import sqlite3
import random
import mimetypes
import threading
import subprocess
import urllib.parse
import urllib.request
from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
# Ensure UTF-8 console output
try:
sys.stdout.reconfigure(encoding='utf-8')
sys.stderr.reconfigure(encoding='utf-8')
except Exception:
pass
IS_CLOUD_ENV = bool(os.environ.get("SPACE_ID") or os.environ.get("RENDER") or os.environ.get("CLOUD_MODE"))
PORT = int(os.environ.get("PORT", os.environ.get("MOCHI_PORT", 7860 if IS_CLOUD_ENV else 8686)))
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
ANKI_USER_DIR = r"E:\AnkiPortable\AnkiData\User 1"
ANKI_COL_PATH = os.path.join(ANKI_USER_DIR, "collection.anki2")
LOCAL_MEDIA_DIR = os.path.join(ANKI_USER_DIR, "collection.media")
CLOUD_MEDIA_DIR = os.path.join(BASE_DIR, "collection.media")
ANKI_MEDIA_DIR = LOCAL_MEDIA_DIR if os.path.isdir(LOCAL_MEDIA_DIR) else CLOUD_MEDIA_DIR
MEDIA_PACK_TAR = os.path.join(BASE_DIR, "media_pack.tar")
SNAPSHOT_DB_PATH = os.path.join(BASE_DIR, "anki_snapshot.db")
PROGRESS_DB_PATH = os.path.join(BASE_DIR, "web_progress.db")
db_lock = threading.Lock()
tunnel_state = {
"running": False,
"public_url": None,
"status": "idle",
"proc": None,
"error": None
}
def get_lan_ip():
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.settimeout(0.5)
s.connect(("8.8.8.8", 80))
ip = s.getsockname()[0]
s.close()
return ip
except Exception:
return "127.0.0.1"
def clean_html(raw):
if not raw:
return ""
txt = str(raw)
txt = re.sub(r"\[sound:[^\]]+\]", "", txt)
txt = re.sub(r"\{\{c\d+::(.*?)(?:::.*?)?\}\}", r"\1", txt, flags=re.IGNORECASE | re.DOTALL)
txt = re.sub(r"<br\s*/?>", " ", txt, flags=re.IGNORECASE)
txt = re.sub(r"<[^>]+>", "", txt)
txt = html.unescape(txt)
txt = txt.replace("\xa0", " ").replace(" ", " ")
return re.sub(r"\s+", " ", txt).strip()
def extract_sound_filename(raw):
if not raw:
return ""
txt = str(raw).strip()
m = re.search(r"\[sound:([^\]]+)\]", txt)
if m:
return m.group(1).strip()
txt = clean_html(txt)
if txt.lower().endswith((".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac")):
return txt
return ""
def is_anki_connect_alive():
try:
with socket.create_connection(("127.0.0.1", 8765), timeout=0.12):
return True
except Exception:
return False
def anki_connect_invoke(action, **params):
"""Gọi AnkiConnect nếu Anki Desktop đang mở (http://127.0.0.1:8765)."""
if not is_anki_connect_alive():
raise ConnectionError("AnkiConnect is not running")
import urllib.request
payload = json.dumps({"action": action, "version": 6, "params": params}).encode("utf-8")
req = urllib.request.Request("http://127.0.0.1:8765", data=payload, headers={"Content-Type": "application/json"})
with urllib.request.urlopen(req, timeout=0.8) as resp:
return json.loads(resp.read().decode("utf-8"))
def init_progress_db():
with db_lock:
conn = sqlite3.connect(PROGRESS_DB_PATH)
conn.execute("""
CREATE TABLE IF NOT EXISTS card_progress (
nid INTEGER PRIMARY KEY,
deck_name TEXT,
word TEXT,
meaning TEXT,
pos TEXT,
pronunciation TEXT,
explain TEXT,
example TEXT,
example_translated TEXT,
collocation TEXT,
synonym TEXT,
antonym TEXT,
audio_word TEXT,
audio_example TEXT,
image TEXT,
choices_json TEXT,
level INTEGER DEFAULT 0,
ivl INTEGER DEFAULT 0,
ease INTEGER DEFAULT 2500,
due_ts INTEGER DEFAULT 0,
reps INTEGER DEFAULT 0,
lapses INTEGER DEFAULT 0,
last_review_ts INTEGER DEFAULT 0
)
""")
conn.execute("""
CREATE TABLE IF NOT EXISTS review_log (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nid INTEGER,
deck_name TEXT,
is_correct INTEGER,
ease_chosen INTEGER,
old_level INTEGER,
new_level INTEGER,
reviewed_at INTEGER
)
""")
conn.execute("""
CREATE TABLE IF NOT EXISTS pending_anki_writes (
nid INTEGER PRIMARY KEY,
is_correct INTEGER,
ease_chosen INTEGER,
new_ivl INTEGER,
old_ivl INTEGER,
ease INTEGER,
reps INTEGER,
lapses INTEGER,
updated_at INTEGER
)
""")
conn.execute("CREATE INDEX IF NOT EXISTS idx_deck_name ON card_progress(deck_name)")
conn.execute("CREATE INDEX IF NOT EXISTS idx_level ON card_progress(level)")
conn.execute("CREATE INDEX IF NOT EXISTS idx_due_ts ON card_progress(due_ts)")
conn.commit()
conn.close()
def ivl_to_level(ctype, ivl):
"""
Quy đổi trạng thái thẻ thực tế trong Anki sang 5 cấp độ MochiVocab:
- ctype == 0: Từ mới chưa học (Level 0)
- ctype in (1, 3) hoặc ivl <= 3 ngày: Cấp độ 1
- ivl 4..10 ngày: Cấp độ 2
- ivl 11..21 ngày: Cấp độ 3
- ivl 22..45 ngày: Cấp độ 4
- ivl > 45 ngày: Cấp độ 5 (Master)
"""
if ctype == 0:
return 0
if ctype in (1, 3) or ivl <= 3:
return 1
elif ivl <= 10:
return 2
elif ivl <= 21:
return 3
elif ivl <= 45:
return 4
else:
return 5
def push_review_to_anki(nid, is_correct, ease_chosen, new_ivl, old_ivl, ease, reps, lapses):
"""
Đồng bộ kết quả ôn tập từ Web ngược về Anki:
1. Nếu Anki Desktop đang mở: Cập nhật trực tiếp qua AnkiConnect (setSpecificValueOfCard + insertReviews).
2. Nếu Anki Desktop đang đóng: Ghi trực tiếp vào E:\\AnkiPortable\\AnkiData\\User 1\\collection.anki2.
"""
now_ts = int(time.time())
now_ms = int(time.time() * 1000)
# Lấy crt từ snapshot hoặc collection để tính ngày due chuẩn của Anki
crt = 1753736400
try:
db_for_crt = SNAPSHOT_DB_PATH if os.path.exists(SNAPSHOT_DB_PATH) else ANKI_COL_PATH
with sqlite3.connect(db_for_crt) as c_crt:
row_crt = c_crt.execute("SELECT crt FROM col LIMIT 1").fetchone()
if row_crt:
crt = int(row_crt[0])
except Exception:
pass
today_days = int((now_ts - crt) // 86400)
new_due_day = today_days + max(1, new_ivl)
# Cách 1: Thử qua AnkiConnect nếu Anki đang mở
try:
cids_res = anki_connect_invoke("findCards", query=f"nid:{nid}")
cids = cids_res.get("result") or []
if cids:
reviews_to_insert = []
for idx, cid in enumerate(cids):
anki_connect_invoke(
"setSpecificValueOfCard",
card=int(cid),
keys=["type", "queue", "ivl", "due", "factor", "reps", "lapses", "mod", "usn"],
newValues=[2, 2, int(new_ivl), int(new_due_day), int(ease), int(reps), int(lapses), now_ts, -1],
warning_check=True
)
reviews_to_insert.append([
now_ms + idx, int(cid), -1, int(ease_chosen),
int(new_ivl), int(old_ivl), int(ease), 4000, 1
])
if reviews_to_insert:
anki_connect_invoke("insertReviews", reviews=reviews_to_insert)
return {"synced_to_anki": True, "mode": "ankiconnect", "cards_updated": len(cids)}
except Exception:
pass
# Cách 2: Ghi trực tiếp vào file collection.anki2 khi Anki đang đóng
try:
aconn = sqlite3.connect(ANKI_COL_PATH, timeout=2.0)
cids = [r[0] for r in aconn.execute("SELECT id FROM cards WHERE nid = ?", (nid,)).fetchall()]
if cids:
aconn.execute("""
UPDATE cards
SET type = 2, queue = 2, ivl = ?, due = ?, factor = ?, reps = ?, lapses = ?, mod = ?, usn = -1
WHERE nid = ?
""", (int(new_ivl), int(new_due_day), int(ease), int(reps), int(lapses), now_ts, int(nid)))
for idx, cid in enumerate(cids):
aconn.execute("""
INSERT OR IGNORE INTO revlog (id, cid, usn, ease, ivl, lastIvl, factor, time, type)
VALUES (?, ?, -1, ?, ?, ?, ?, 4000, 1)
""", (now_ms + idx, int(cid), int(ease_chosen), int(new_ivl), int(old_ivl), int(ease)))
aconn.commit()
aconn.close()
return {"synced_to_anki": True, "mode": "sqlite_direct", "cards_updated": len(cids)}
except Exception as e:
# Lưu vào hàng đợi chờ đồng bộ khi Anki đóng
with db_lock:
pconn = sqlite3.connect(PROGRESS_DB_PATH)
pconn.execute("""
INSERT OR REPLACE INTO pending_anki_writes
(nid, is_correct, ease_chosen, new_ivl, old_ivl, ease, reps, lapses, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
""", (nid, 1 if is_correct else 0, ease_chosen, new_ivl, old_ivl, ease, reps, lapses, now_ts))
pconn.commit()
pconn.close()
return {"synced_to_anki": False, "mode": "queued", "error": str(e)}
def flush_pending_anki_writes():
with db_lock:
conn = sqlite3.connect(PROGRESS_DB_PATH)
rows = conn.execute("SELECT nid, is_correct, ease_chosen, new_ivl, old_ivl, ease, reps, lapses FROM pending_anki_writes").fetchall()
conn.close()
if not rows:
return 0
flushed = 0
for nid, is_corr, ease_c, new_ivl, old_ivl, ease, reps, lapses in rows:
res = push_review_to_anki(nid, bool(is_corr), ease_c, new_ivl, old_ivl, ease, reps, lapses)
if res.get("synced_to_anki"):
flushed += 1
with db_lock:
conn = sqlite3.connect(PROGRESS_DB_PATH)
conn.execute("DELETE FROM pending_anki_writes WHERE nid = ?", (nid,))
conn.commit()
conn.close()
return flushed
def sync_from_anki_collection(force_overwrite_srs=False):
"""
Sao chép an toàn collection.anki2 (kể cả khi Anki đang mở) và đồng bộ chính xác tiến độ Anki <-> Web.
"""
if not os.path.exists(ANKI_COL_PATH):
print(f"[WARN] Không tìm thấy {ANKI_COL_PATH}")
return {"synced": 0, "error": "Anki collection file not found"}
flush_pending_anki_writes()
try:
shutil.copy2(ANKI_COL_PATH, SNAPSHOT_DB_PATH)
for ext in ("-wal", "-shm"):
if os.path.exists(ANKI_COL_PATH + ext):
shutil.copy2(ANKI_COL_PATH + ext, SNAPSHOT_DB_PATH + ext)
elif os.path.exists(SNAPSHOT_DB_PATH + ext):
try:
os.remove(SNAPSHOT_DB_PATH + ext)
except Exception:
pass
except Exception as e:
return {"synced": 0, "error": str(e)}
anki_conn = sqlite3.connect(SNAPSHOT_DB_PATH)
crt_row = anki_conn.execute("SELECT crt FROM col LIMIT 1").fetchone()
crt = int(crt_row[0]) if crt_row else 1753736400
now_ts = int(time.time())
today_days = int((now_ts - crt) // 86400)
decks_map = {}
for did, dname in anki_conn.execute("SELECT id, name FROM decks").fetchall():
decks_map[did] = dname.replace("\x1f", "::")
fields_map = {}
for ntid, ord_idx, fname in anki_conn.execute("SELECT ntid, ord, name FROM fields ORDER BY ntid, ord").fetchall():
fields_map.setdefault(ntid, []).append(fname)
rows = anki_conn.execute("""
SELECT n.id, n.mid, n.flds,
c.did,
MAX(c.ivl),
MAX(c.type),
MAX(c.factor),
SUM(c.reps),
SUM(c.lapses),
MIN(CASE
WHEN c.queue IN (1, 3) THEN ?
WHEN c.queue = 2 THEN c.due
ELSE 999999
END),
MAX(c.mod)
FROM notes n
JOIN cards c ON c.nid = n.id
GROUP BY n.id
""", (today_days,)).fetchall()
anki_conn.close()
synced_count = 0
with db_lock:
pconn = sqlite3.connect(PROGRESS_DB_PATH)
pending_nids = set(r[0] for r in pconn.execute("SELECT nid FROM pending_anki_writes").fetchall())
existing_srs = {}
if not force_overwrite_srs:
for r in pconn.execute("SELECT nid, level, ivl, ease, due_ts, reps, lapses, last_review_ts FROM card_progress").fetchall():
existing_srs[r[0]] = r[1:]
batch = []
for nid, mid, flds_raw, did, max_ivl, max_type, max_factor, sum_reps, sum_lapses, min_due_day, max_mod in rows:
fnames = fields_map.get(mid, [])
fvals = flds_raw.split("\x1f")
fdict = {}
for i, fn in enumerate(fnames):
if i < len(fvals):
fdict[fn.lower().strip()] = fvals[i]
deck_name = decks_map.get(did, "Default")
word_raw = fdict.get("word") or fdict.get("front") or fdict.get("vocabulary") or fdict.get("từ vựng") or fdict.get("learnable") or ""
meaning_raw = fdict.get("meaning") or fdict.get("definition") or fdict.get("back") or fdict.get("nghĩa tiếng việt") or ""
explain_raw = fdict.get("explain") or ""
if not meaning_raw and explain_raw:
meaning_raw, explain_raw = explain_raw, ""
if fdict.get("definition") and fdict.get("meaning") and fdict.get("definition") != fdict.get("meaning") and not explain_raw:
explain_raw = fdict.get("meaning")
meaning_raw = fdict.get("definition")
word = clean_html(word_raw)
meaning = clean_html(meaning_raw)
if not word or not meaning:
continue
pos = clean_html(fdict.get("pos") or fdict.get("part of speech") or fdict.get("từ loại") or "")
pron = clean_html(fdict.get("pronunciation") or fdict.get("phonetic") or fdict.get("ipa") or "").strip("/")
explain = clean_html(explain_raw)
example = clean_html(fdict.get("example") or fdict.get("cloze sentence") or fdict.get("ví dụ") or fdict.get("ví dụ 1") or "")
ex_trans = clean_html(fdict.get("example_translated") or fdict.get("example meaning") or "")
collocation = clean_html(fdict.get("collocation") or "")
synonym = clean_html(fdict.get("synonym") or fdict.get("synonyms") or "")
antonym = clean_html(fdict.get("antonym") or "")
audio_word = extract_sound_filename(fdict.get("audio_word") or fdict.get("audio_for_word") or word_raw or "")
audio_ex = extract_sound_filename(fdict.get("audio") or fdict.get("sound") or fdict.get("example") or fdict.get("cloze sentence") or fdict.get("ví dụ") or "")
if not audio_word and audio_ex and not example:
audio_word = audio_ex
choices_meta = {
"meaning_choices": [clean_html(fdict.get(f"choice_{i}", "")) for i in (1, 2, 3, 4) if clean_html(fdict.get(f"choice_{i}", ""))],
"correct_choice": int(clean_html(fdict.get("correct_choice", "1"))) if clean_html(fdict.get("correct_choice", "")).isdigit() else 1,
"word_choices": [clean_html(fdict.get(f"choice_word_{i}", "")) for i in (1, 2, 3, 4) if clean_html(fdict.get(f"choice_word_{i}", ""))],
"correct_choice_word": int(clean_html(fdict.get("correct_choice_word", "1"))) if clean_html(fdict.get("correct_choice_word", "")).isdigit() else 1,
"audio_choices": [extract_sound_filename(fdict.get(f"choice_audio_{i}", "")) for i in (1, 2, 3, 4) if extract_sound_filename(fdict.get(f"choice_audio_{i}", ""))],
"correct_choice_audio": int(clean_html(fdict.get("correct_choice_audio", "1"))) if clean_html(fdict.get("correct_choice_audio", "")).isdigit() else 1,
}
max_ivl = max_ivl or 0
max_type = max_type or 0
max_mod = max_mod or 0
anki_lvl = ivl_to_level(max_type, max_ivl)
if max_type == 0:
anki_due_ts = 0
elif min_due_day is not None and min_due_day <= today_days:
anki_due_ts = crt + (int(min_due_day) * 86400)
elif min_due_day is not None and min_due_day < 900000:
anki_due_ts = max(now_ts + 3600, crt + (int(min_due_day) * 86400))
else:
anki_due_ts = now_ts + (max(1, max_ivl) * 86400)
# Anki là nguồn dữ liệu gốc (chỉ giữ trạng thái tạm nếu thẻ đang nằm trong hàng đợi pending_anki_writes chưa kịp ghi)
if nid in pending_nids and nid in existing_srs and not force_overwrite_srs:
lvl, ivl, ease, due_ts, reps, lapses, last_rev = existing_srs[nid]
else:
lvl = anki_lvl
ivl = max(0, max_ivl)
ease = max_factor or 2500
due_ts = anki_due_ts
reps = sum_reps or 0
lapses = sum_lapses or 0
last_rev = 0
batch.append((
nid, deck_name, word, meaning, pos, pron, explain,
example, ex_trans, collocation, synonym, antonym,
audio_word, audio_ex, "", json.dumps(choices_meta, ensure_ascii=False),
lvl, ivl, ease, due_ts, reps, lapses, last_rev
))
synced_count += 1
valid_nids = {r[0] for r in rows}
all_prog_nids = {r[0] for r in pconn.execute("SELECT nid FROM card_progress").fetchall()}
stale_nids = all_prog_nids - valid_nids
if stale_nids:
pconn.executemany("DELETE FROM card_progress WHERE nid = ?", [(x,) for x in stale_nids])
pconn.executemany("""
INSERT OR REPLACE INTO card_progress (
nid, deck_name, word, meaning, pos, pronunciation, explain,
example, example_translated, collocation, synonym, antonym,
audio_word, audio_example, image, choices_json,
level, ivl, ease, due_ts, reps, lapses, last_review_ts
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
""", batch)
pconn.commit()
pconn.close()
return {"synced": synced_count, "error": None}
def get_dashboard_stats(deck_filter="french2"):
now_ts = int(time.time())
today_start = now_ts - (now_ts % 86400)
with db_lock:
conn = sqlite3.connect(PROGRESS_DB_PATH)
decks_rows = conn.execute("""
SELECT deck_name, COUNT(*),
SUM(CASE WHEN level > 0 AND due_ts <= ? THEN 1 ELSE 0 END),
SUM(CASE WHEN level = 0 THEN 1 ELSE 0 END)
FROM card_progress
GROUP BY deck_name
ORDER BY CASE WHEN deck_name = 'french2' THEN 0 WHEN deck_name = 'hoc_lom' THEN 1 WHEN deck_name = 'French' THEN 2 ELSE 3 END, COUNT(*) DESC
""", (now_ts,)).fetchall()
decks_list = [{"name": r[0], "total": r[1], "due": r[2], "new": r[3]} for r in decks_rows]
if not deck_filter or deck_filter == "ALL":
where_clause = ""
params = ()
else:
where_clause = "WHERE deck_name = ? OR deck_name LIKE ?"
params = (deck_filter, f"{deck_filter}::%")
lvl_rows = conn.execute(f"""
SELECT level, COUNT(*)
FROM card_progress
{where_clause}
GROUP BY level
""", params).fetchall()
levels = [0, 0, 0, 0, 0]
new_count = 0
for lvl, cnt in lvl_rows:
lvl_int = int(lvl or 0)
if lvl_int == 0:
new_count += cnt
elif 1 <= lvl_int <= 5:
levels[lvl_int - 1] += cnt
total_learned = sum(levels)
due_row = conn.execute(f"""
SELECT COUNT(*)
FROM card_progress
{where_clause + (' AND ' if where_clause else 'WHERE ')} (level > 0 AND due_ts <= ?)
""", params + (now_ts,)).fetchone()
due_count = due_row[0] if due_row else 0
today_rev = conn.execute("""
SELECT COUNT(*), SUM(CASE WHEN is_correct = 1 THEN 1 ELSE 0 END)
FROM review_log
WHERE reviewed_at >= ?
""", (today_start,)).fetchone()
conn.close()
reviewed_today = today_rev[0] or 0
correct_today = today_rev[1] or 0
return {
"selected_deck": deck_filter,
"decks": decks_list,
"levels": levels,
"new_count": new_count,
"total_learned": total_learned,
"total_words": total_learned + new_count,
"due_count": due_count,
"reviewed_today": reviewed_today,
"correct_today": correct_today,
"lan_url": f"http://{get_lan_ip()}:{PORT}",
"public_url": tunnel_state.get("public_url"),
"tunnel_status": tunnel_state.get("status")
}
_ANKI_LIVE_CACHE = {"ts": 0, "due": None, "new": None, "stats": {}, "refreshing": False}
def _do_anki_live_refresh(decks):
try:
if not is_anki_connect_alive():
_ANKI_LIVE_CACHE["ts"] = time.time()
_ANKI_LIVE_CACHE["due"] = None
_ANKI_LIVE_CACHE["new"] = None
_ANKI_LIVE_CACHE["stats"] = {}
return
live_due_nids = None
live_new_nids = None
anki_deck_stats = {}
ac_res = anki_connect_invoke("findNotes", query="(is:due OR is:learn) -is:suspended -is:buried")
if isinstance(ac_res, dict) and ac_res.get("error") is None and isinstance(ac_res.get("result"), list):
live_due_nids = set(int(x) for x in ac_res["result"])
new_res = anki_connect_invoke("findNotes", query="is:new -is:suspended -is:buried")
if isinstance(new_res, dict) and new_res.get("error") is None and isinstance(new_res.get("result"), list):
live_new_nids = set(int(x) for x in new_res["result"])
if decks:
st_res = anki_connect_invoke("getDeckStats", decks=decks)
if isinstance(st_res, dict) and isinstance(st_res.get("result"), dict):
for _, dinfo in st_res["result"].items():
if isinstance(dinfo, dict) and dinfo.get("name"):
anki_deck_stats[dinfo["name"]] = {
"new_count": int(dinfo.get("new_count") or 0),
"learn_count": int(dinfo.get("learn_count") or 0),
"review_count": int(dinfo.get("review_count") or 0),
"total_in_deck": int(dinfo.get("total_in_deck") or 0)
}
_ANKI_LIVE_CACHE["ts"] = time.time()
_ANKI_LIVE_CACHE["due"] = live_due_nids
_ANKI_LIVE_CACHE["new"] = live_new_nids
_ANKI_LIVE_CACHE["stats"] = anki_deck_stats
except Exception:
_ANKI_LIVE_CACHE["ts"] = time.time()
finally:
_ANKI_LIVE_CACHE["refreshing"] = False
def _refresh_anki_live_cache(decks):
now = time.time()
if _ANKI_LIVE_CACHE["ts"] == 0:
_ANKI_LIVE_CACHE["refreshing"] = True
_do_anki_live_refresh(decks)
elif now - _ANKI_LIVE_CACHE["ts"] > 5.0 and not _ANKI_LIVE_CACHE["refreshing"]:
_ANKI_LIVE_CACHE["refreshing"] = True
threading.Thread(target=_do_anki_live_refresh, args=(decks,), daemon=True).start()
return _ANKI_LIVE_CACHE["due"], _ANKI_LIVE_CACHE["new"], _ANKI_LIVE_CACHE["stats"]
def fetch_all_cards_for_web(deck="ALL"):
"""Trả về toàn bộ danh sách thẻ kèm trạng thái SRS từ Anki để giao diện MochiVocab hiển thị tức thì."""
now_ts = int(time.time())
with db_lock:
conn = sqlite3.connect(PROGRESS_DB_PATH)
conn.row_factory = sqlite3.Row
if deck and deck != "ALL":
rows = conn.execute("""
SELECT * FROM card_progress
WHERE deck_name = ? OR deck_name LIKE ?
ORDER BY due_ts ASC, nid ASC
""", (deck, f"{deck}::%")).fetchall()
else:
rows = conn.execute("SELECT * FROM card_progress ORDER BY due_ts ASC, nid ASC").fetchall()
decks = [r[0] for r in conn.execute("""
SELECT deck_name FROM card_progress
GROUP BY deck_name
ORDER BY CASE WHEN deck_name = 'french2' THEN 0 WHEN deck_name = 'hoc_lom' THEN 1 WHEN deck_name = 'French' THEN 2 ELSE 3 END, COUNT(*) DESC
""").fetchall()]
conn.close()
live_due_nids, live_new_nids, anki_deck_stats = _refresh_anki_live_cache(decks)
cards_out = []
for r in rows:
pron = r["pronunciation"] or ""
if pron and not pron.startswith("/"):
pron = f"/{pron}/"
meaning_str = r["meaning"] or ""
explain_str = r["explain"] or ""
if meaning_str and explain_str and explain_str.lower() != meaning_str.lower():
full_meaning = f"{meaning_str} — {explain_str}"
else:
full_meaning = meaning_str or explain_str
cmeta = {}
try:
cmeta = json.loads(r["choices_json"] or "{}")
except Exception:
pass
nid_val = int(r["nid"])
lvl_val = int(r["level"] or 0)
due_val = int(r["due_ts"] or 0)
has_anki_new = bool(live_new_nids and nid_val in live_new_nids) or (lvl_val == 0)
if live_due_nids is not None:
if nid_val in live_due_nids:
lvl_val = max(1, lvl_val)
due_val = min(due_val if due_val > 0 else now_ts, now_ts - 60)
else:
if lvl_val > 0 and due_val <= now_ts:
due_val = now_ts + 86400
cards_out.append({
"nid": nid_val,
"deck": r["deck_name"],
"word": r["word"],
"meaning": full_meaning,
"raw_meaning": meaning_str,
"explain": explain_str,
"pos": r["pos"],
"ipa": pron,
"pronunciation": r["pronunciation"],
"example": r["example"],
"example_trans": r["example_translated"],
"example_translated": r["example_translated"],
"collocation": r["collocation"],
"synonym": r["synonym"],
"antonym": r["antonym"],
"word_audio": r["audio_word"],
"audio_word": r["audio_word"],
"example_audio": r["audio_example"],
"audio_example": r["audio_example"],
"choices": cmeta,
"level": lvl_val,
"ivl": r["ivl"],
"next_review": due_val,
"reps": r["reps"],
"has_anki_new": has_anki_new
})
return {"cards": cards_out, "decks": decks, "deck_stats": anki_deck_stats}
def record_card_review(nid, is_correct, ease_chosen=None):
"""
Cập nhật cấp độ nhớ (Level 1 -> 5), lưu vào web_progress.db VÀ đồng bộ ngược về Anki ở luồng nền (0ms delay)!
"""
now_ts = int(time.time())
if ease_chosen is None:
ease_chosen = 3 if is_correct else 1
with db_lock:
conn = sqlite3.connect(PROGRESS_DB_PATH)
row = conn.execute(
"SELECT deck_name, level, ivl, ease, reps, lapses FROM card_progress WHERE nid = ?",
(nid,)
).fetchone()
if not row:
conn.close()
return None
deck_name, old_lvl, old_ivl, ease, reps, lapses = row
old_lvl = old_lvl or 0
old_ivl = old_ivl or 0
ease = ease or 2500
reps = (reps or 0) + 1
lapses = lapses or 0
if ease_chosen == 1 or not is_correct:
new_lvl = 1
new_ivl = 1
ease = max(1300, ease - 200)
lapses += 1
elif ease_chosen == 2:
new_lvl = max(1, old_lvl)
new_ivl = max(2, int(old_ivl * 1.2) if old_ivl > 0 else 2)
ease = max(1300, ease - 150)
elif ease_chosen == 3:
new_lvl = min(5, (1 if old_lvl == 0 else old_lvl + 1))
level_default_ivls = {1: 2, 2: 6, 3: 14, 4: 30, 5: 60}
new_ivl = max(level_default_ivls.get(new_lvl, 4), int(old_ivl * (ease / 1000.0)) if old_ivl > 0 else 2)
else: # ease 4 (Easy)
new_lvl = min(5, (2 if old_lvl <= 1 else old_lvl + 1))
level_default_ivls = {1: 4, 2: 8, 3: 18, 4: 35, 5: 60}
new_ivl = max(level_default_ivls.get(new_lvl, 7), int(old_ivl * (ease / 1000.0) * 1.3) if old_ivl > 0 else 4)
ease = min(3500, ease + 150)
due_ts = now_ts + (new_ivl * 86400)
conn.execute("""
UPDATE card_progress
SET level = ?, ivl = ?, ease = ?, due_ts = ?, reps = ?, lapses = ?, last_review_ts = ?
WHERE nid = ?
""", (new_lvl, new_ivl, ease, due_ts, reps, lapses, now_ts, nid))
conn.execute("""
INSERT INTO review_log (nid, deck_name, is_correct, ease_chosen, old_level, new_level, reviewed_at)
VALUES (?, ?, ?, ?, ?, ?, ?)
""", (nid, deck_name, 1 if is_correct else 0, ease_chosen, old_lvl, new_lvl, now_ts))
conn.commit()
conn.close()
if _ANKI_LIVE_CACHE["due"] and nid in _ANKI_LIVE_CACHE["due"]:
_ANKI_LIVE_CACHE["due"].discard(nid)
threading.Thread(
target=push_review_to_anki,
args=(nid, is_correct, ease_chosen, new_ivl, old_ivl, ease, reps, lapses),
daemon=True
).start()
return {
"nid": nid,
"old_level": old_lvl,
"level": new_lvl,
"new_level": new_lvl,
"new_ivl": new_ivl,
"next_review": due_ts,
"anki_sync": {"synced_to_anki": True, "mode": "background"}
}
def search_notebook_words(deck="french2", level=0, query="", limit=150):
with db_lock:
conn = sqlite3.connect(PROGRESS_DB_PATH)
conn.row_factory = sqlite3.Row
conds = []
params = []
if deck and deck != "ALL":
conds.append("(deck_name = ? OR deck_name LIKE ?)")
params.extend([deck, f"{deck}::%"])
if level in (1, 2, 3, 4, 5):
conds.append("level = ?")
params.append(level)
if query:
q_like = f"%{query.strip()}%"
conds.append("(word LIKE ? OR meaning LIKE ? OR explain LIKE ?)")
params.extend([q_like, q_like, q_like])
where_sql = ("WHERE " + " AND ".join(conds)) if conds else ""
rows = conn.execute(f"""
SELECT nid, word, meaning, explain, pos, pronunciation, example, audio_word, audio_example, level, ivl
FROM card_progress
{where_sql}
ORDER BY level ASC, word ASC
LIMIT ?
""", params + [limit]).fetchall()
conn.close()
return [dict(r) for r in rows]
def start_public_tunnel():
"""
Khởi tạo đường truyền Internet công khai qua SSH localhost.run (tích hợp sẵn trên Windows 10/11)
để học trên điện thoại bằng 4G/5G ở bất kỳ đâu không cần chung mạng Wi-Fi.
"""
if tunnel_state["running"] and tunnel_state["proc"] and tunnel_state["proc"].poll() is None:
return tunnel_state
ssh_bin = shutil.which("ssh") or r"C:\Windows\System32\OpenSSH\ssh.exe"
if not os.path.exists(ssh_bin):
tunnel_state["status"] = "error"
tunnel_state["error"] = "Không tìm thấy OpenSSH trên hệ thống."
return tunnel_state
tunnel_state["status"] = "connecting"
tunnel_state["error"] = None
def _runner():
try:
cmd = [
ssh_bin,
"-o", "StrictHostKeyChecking=no",
"-o", "UserKnownHostsFile=/dev/null",
"-o", "ServerAliveInterval=30",
"-R", f"80:127.0.0.1:{PORT}",
"nokey@localhost.run"
]
proc = subprocess.Popen(
cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True,
encoding="utf-8",
errors="replace",
creationflags= getattr(subprocess, "CREATE_NO_WINDOW", 0)
)
tunnel_state["proc"] = proc
tunnel_state["running"] = True
for line in proc.stdout:
m = re.search(r"(https://[a-zA-Z0-9.-]+\.lhr\.life)", line)
if m:
tunnel_state["public_url"] = m.group(1)
tunnel_state["status"] = "connected"
print(f"[PUBLIC INTERNET URL] {tunnel_state['public_url']}")
except Exception as e:
tunnel_state["status"] = "error"
tunnel_state["error"] = str(e)
finally:
tunnel_state["running"] = False
if tunnel_state["status"] != "error":
tunnel_state["status"] = "idle"
tunnel_state["public_url"] = None
t = threading.Thread(target=_runner, daemon=True)
t.start()
return tunnel_state
class MochiWebHandler(SimpleHTTPRequestHandler):
protocol_version = "HTTP/1.1"
def log_message(self, format, *args):
pass # Giữ console gọn gàng
def send_json(self, data, status=200):
raw = json.dumps(data, ensure_ascii=False).encode("utf-8")
accept_enc = self.headers.get("Accept-Encoding", "")
if len(raw) > 8192 and "gzip" in accept_enc:
import gzip
raw = gzip.compress(raw, compresslevel=5)
self.send_response(status)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Encoding", "gzip")
self.send_header("Content-Length", str(len(raw)))
self.send_header("Access-Control-Allow-Origin", "*")
self.end_headers()
self.wfile.write(raw)
return
self.send_response(status)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(raw)))
self.send_header("Access-Control-Allow-Origin", "*")
self.end_headers()
self.wfile.write(raw)
def do_OPTIONS(self):
self.send_response(200)
self.send_header("Access-Control-Allow-Origin", "*")
self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
self.send_header("Access-Control-Allow-Headers", "Content-Type")
self.end_headers()
def do_GET(self):
parsed = urllib.parse.urlparse(self.path)
path = parsed.path
qs = urllib.parse.parse_qs(parsed.query)
if path == "/" or path == "/index.html":
index_file = os.path.join(BASE_DIR, "index.html")
if os.path.isfile(index_file):
with open(index_file, "rb") as f:
content = f.read()
self.send_response(200)
self.send_header("Content-Type", "text/html; charset=utf-8")
self.send_header("Content-Length", str(len(content)))
self.end_headers()
self.wfile.write(content)
return
if path == "/manifest.json":
manifest = {
"name": "Mochi French Web — Học Từ Vựng Mọi Nơi",
"short_name": "MochiFrench",
"start_url": "/",
"display": "standalone",
"background_color": "#0f172a",
"theme_color": "#f59e0b",
"icons": [
{
"src": "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><circle cx='50' cy='50' r='48' fill='%23f59e0b'/><text x='50' y='68' font-size='55' text-anchor='middle'>🐱</text></svg>",
"sizes": "192x192",
"type": "image/svg+xml"
}
]
}
return self.send_json(manifest)
if path.startswith("/media/"):
filename = urllib.parse.unquote(path[len("/media/"):]).strip()
filename = os.path.basename(filename)
media_file = os.path.join(ANKI_MEDIA_DIR, filename)
if not os.path.isfile(media_file):
try:
os.makedirs(ANKI_MEDIA_DIR, exist_ok=True)
text_to_speak = ""
tl_lang = "fr"
with sqlite3.connect(PROGRESS_DB_PATH) as conn:
r = conn.execute(
"SELECT word, example, deck_name FROM card_progress WHERE audio_word = ? OR audio_example = ? LIMIT 1",
(filename, filename)
).fetchone()
if r:
raw_w, raw_ex, d_name = r
if str(d_name or "").lower().startswith("hoc_lom"):
tl_lang = "en"
row_check = conn.execute(
"SELECT audio_word FROM card_progress WHERE audio_word = ? LIMIT 1",
(filename,)
).fetchone()
text_to_speak = clean_html(raw_w if row_check else (raw_ex or raw_w))
text_to_speak = re.sub(r"\s*\([mf]\.?\)", "", text_to_speak, flags=re.I).strip()
if text_to_speak:
tts_url = f"https://translate.google.com/translate_tts?ie=UTF-8&q={urllib.parse.quote(text_to_speak[:180])}&tl={tl_lang}&client=tw-ob"
req = urllib.request.Request(tts_url, headers={"User-Agent": "Mozilla/5.0"})
with urllib.request.urlopen(req, timeout=2.5) as resp:
audio_bytes = resp.read()
if len(audio_bytes) > 400:
with open(media_file, "wb") as f_out:
f_out.write(audio_bytes)
except Exception:
pass
if os.path.isfile(media_file):
ctype, _ = mimetypes.guess_type(media_file)
if not ctype:
ctype = "audio/mpeg" if filename.lower().endswith(".mp3") else "application/octet-stream"
file_size = os.path.getsize(media_file)
range_header = self.headers.get("Range")
if range_header:
m = re.match(r"bytes=(\d+)-(\d*)", range_header)
if m:
start = int(m.group(1))
end = int(m.group(2)) if m.group(2) else file_size - 1
end = min(end, file_size - 1)
length = max(0, end - start + 1)
with open(media_file, "rb") as f:
f.seek(start)
chunk = f.read(length)
self.send_response(206)
self.send_header("Content-Type", ctype)
self.send_header("Accept-Ranges", "bytes")
self.send_header("Content-Range", f"bytes {start}-{end}/{file_size}")
self.send_header("Content-Length", str(len(chunk)))
self.send_header("Cache-Control", "public, max-age=86400")
self.end_headers()
self.wfile.write(chunk)
return
with open(media_file, "rb") as f:
data = f.read()
self.send_response(200)
self.send_header("Content-Type", ctype)
self.send_header("Accept-Ranges", "bytes")
self.send_header("Content-Length", str(len(data)))
self.send_header("Cache-Control", "public, max-age=86400")
self.end_headers()
self.wfile.write(data)
return
else:
self.send_response(404)
self.end_headers()
return
if path == "/api/stats":
deck = qs.get("deck", ["french2"])[0]
return self.send_json(get_dashboard_stats(deck))
if path == "/api/cards":
deck = qs.get("deck", ["ALL"])[0]
data = fetch_all_cards_for_web(deck=deck)
return self.send_json(data)
if path == "/api/notebook":
deck = qs.get("deck", ["french2"])[0]
lvl = int(qs.get("level", ["0"])[0])
q = qs.get("q", [""])[0]
words = search_notebook_words(deck=deck, level=lvl, query=q, limit=200)
return self.send_json({"words": words})
if path == "/api/cloud/pull_reviews":
with db_lock:
conn = sqlite3.connect(PROGRESS_DB_PATH)
conn.row_factory = sqlite3.Row
pending = [dict(r) for r in conn.execute("SELECT * FROM pending_anki_writes").fetchall()]
conn.close()
return self.send_json({"ok": True, "pending": pending})
if path == "/api/tunnel":
return self.send_json({
"lan_url": f"http://{get_lan_ip()}:{PORT}",
"public_url": tunnel_state.get("public_url"),
"status": tunnel_state.get("status"),
"error": tunnel_state.get("error")
})
return super().do_GET()
def do_POST(self):
parsed = urllib.parse.urlparse(self.path)
path = parsed.path
length = int(self.headers.get("Content-Length", 0))
body = {}
if length > 0:
try:
body = json.loads(self.rfile.read(length).decode("utf-8"))
except Exception:
body = {}
if path == "/api/review":
nid = body.get("nid")
is_correct = bool(body.get("correct", body.get("is_correct", True)))
ease = body.get("ease")
if nid is not None:
res = record_card_review(int(nid), is_correct, int(ease) if ease else None)
out = {"ok": True, "result": res}
if res:
out.update(res)
return self.send_json(out)
return self.send_json({"ok": False, "error": "Missing nid"}, 400)
if path == "/api/sync":
force = bool(body.get("force", False))
try:
import Deploy_Va_Dong_Bo_Cloud as cloud_sync
from huggingface_hub import HfApi
cfg = cloud_sync.load_config()
tok = (cfg.get("token") or cfg.get("hf_token") or "").strip()
uname = cfg.get("username", "hung9066").strip()
ds_repo = f"{uname}/{cfg.get('dataset_name', 'mochi-french-anki-data')}"
sp_repo = f"{uname}/{cfg.get('space_name', 'mochi-french-anki')}"
if tok:
api = HfApi(token=tok)
cloud_sync.sync_vocab_txt_and_anki(api, ds_repo)
cloud_sync.pull_cloud_reviews_into_anki(api, ds_repo)
except Exception as e:
print(f"[!] Cloud pull warning: {e}")
info = sync_from_anki_collection(force_overwrite_srs=force)
def _bg_push_cloud():
try:
import Deploy_Va_Dong_Bo_Cloud as cloud_sync
from huggingface_hub import HfApi
cfg = cloud_sync.load_config()
tok = (cfg.get("token") or cfg.get("hf_token") or "").strip()
uname = cfg.get("username", "hung9066").strip()
ds_repo = f"{uname}/{cfg.get('dataset_name', 'mochi-french-anki-data')}"
sp_repo = f"{uname}/{cfg.get('space_name', 'mochi-french-anki')}"
if tok:
api = HfApi(token=tok)
cards, cards_json_path = cloud_sync.export_cards_json()
cloud_sync.deploy_static_space(api, sp_repo, cards_json_path)
cloud_sync.deploy_dataset_and_media(api, ds_repo, cards, cards_json_path, upload_media=False)
except Exception:
pass
threading.Thread(target=_bg_push_cloud, daemon=True).start()
return self.send_json({"ok": True, "sync": info})
if path == "/api/cloud/ack_reviews":
nids = body.get("nids", [])
if nids:
with db_lock:
conn = sqlite3.connect(PROGRESS_DB_PATH)
conn.executemany("DELETE FROM pending_anki_writes WHERE nid = ?", [(int(x),) for x in nids])
conn.commit()
conn.close()
return self.send_json({"ok": True, "cleared": len(nids)})
if path == "/api/cloud/push_cards":
cards = body.get("cards", [])
if cards:
with db_lock:
conn = sqlite3.connect(PROGRESS_DB_PATH)
for c in cards:
conn.execute("""
INSERT OR REPLACE INTO card_progress (
nid, deck_name, word, meaning, pos, pronunciation,
explain, example, example_translated, collocation,
synonym, antonym, audio_word, audio_example, image,
choices_json, level, ivl, ease, due_ts, reps, lapses, last_review_ts
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
""", (
c["nid"], c["deck_name"], c["word"], c["meaning"], c["pos"], c["pronunciation"],
c["explain"], c["example"], c["example_translated"], c["collocation"],
c["synonym"], c["antonym"], c["audio_word"], c["audio_example"], c["image"],
c["choices_json"], c["level"], c["ivl"], c["ease"], c["due_ts"], c["reps"], c["lapses"], c["last_review_ts"]
))
conn.commit()
conn.close()
return self.send_json({"ok": True, "updated": len(cards)})
if path == "/api/tunnel/start":
start_public_tunnel()
for _ in range(14):
if tunnel_state.get("public_url") or tunnel_state.get("status") == "error":
break
time.sleep(0.25)
return self.send_json({
"lan_url": f"http://{get_lan_ip()}:{PORT}",
"public_url": tunnel_state.get("public_url"),
"status": tunnel_state.get("status"),
"error": tunnel_state.get("error")
})
return self.send_json({"error": "Not found"}, 404)
def extract_media_pack_if_needed():
if os.path.isfile(MEDIA_PACK_TAR) and not os.path.isdir(LOCAL_MEDIA_DIR):
os.makedirs(CLOUD_MEDIA_DIR, exist_ok=True)
marker = os.path.join(CLOUD_MEDIA_DIR, ".extracted_ok")
if not os.path.isfile(marker):
print(" 📦 Đang giải nén gói âm thanh media_pack.tar trên Cloud...")
import tarfile
try:
with tarfile.open(MEDIA_PACK_TAR, "r") as tf:
tf.extractall(CLOUD_MEDIA_DIR)
with open(marker, "w") as mf:
mf.write("ok")
print(" ✓ Đã giải nén toàn bộ âm thanh Anki thành công!")
except Exception as e:
print(f" [!] Lỗi giải nén media_pack.tar: {e}")
def disable_windows_console_quickedit():
if os.name == "nt":
try:
import ctypes
kernel32 = ctypes.windll.kernel32
stdin_handle = kernel32.GetStdHandle(-10) # STD_INPUT_HANDLE
mode = ctypes.c_uint32()
if kernel32.GetConsoleMode(stdin_handle, ctypes.byref(mode)):
# Clear ENABLE_QUICK_EDIT_MODE (0x0040), set ENABLE_EXTENDED_FLAGS (0x0080)
new_mode = (mode.value & ~0x0040) | 0x0080
kernel32.SetConsoleMode(stdin_handle, new_mode)
except Exception:
pass
def main():
disable_windows_console_quickedit()
print("=" * 64)
print(" 🚀 MOCHI FRENCH & ANKI WEB SERVER (LOCAL & CLOUD 24/7)")
print("=" * 64)
extract_media_pack_if_needed()
init_progress_db()
sync_info = sync_from_anki_collection(force_overwrite_srs=False)
print(f" ✓ Đã đồng bộ dữ liệu từ Anki: {sync_info.get('synced', 0)} từ vựng")
print(f" ✓ Thư mục âm thanh gốc : {ANKI_MEDIA_DIR}")
lan_ip = get_lan_ip()
print(f" 💻 Học trên máy tính này : http://localhost:{PORT}")
print(f" 📱 Học trên ĐT / iPad (WiFi): http://{lan_ip}:{PORT}")
if not IS_CLOUD_ENV:
start_public_tunnel()
print(" 🌐 Đang khởi tạo Link Internet 4G/5G công khai...")
print("=" * 64)
os.chdir(BASE_DIR)
threading.Thread(target=lambda: fetch_all_cards_for_web("ALL"), daemon=True).start()
ThreadingHTTPServer.allow_reuse_address = True
server = ThreadingHTTPServer(("0.0.0.0", PORT), MochiWebHandler)
# Bật thêm IPv6 [::1] trên Windows để trình duyệt gọi localhost:8686 phản hồi trong 0.1ms (không bị chờ 2s IPv6 fallback)
try:
class ThreadingHTTPServerV6(ThreadingHTTPServer):
address_family = socket.AF_INET6
server_v6 = ThreadingHTTPServerV6(("::1", PORT), MochiWebHandler)
threading.Thread(target=server_v6.serve_forever, daemon=True).start()
except Exception:
pass
if "--open-browser" in sys.argv:
def _open_url():
time.sleep(0.3)
try:
import webbrowser
webbrowser.open(f"http://localhost:{PORT}")
except Exception:
pass
threading.Thread(target=_open_url, daemon=True).start()
try:
server.serve_forever()
except KeyboardInterrupt:
print("\nĐã dừng server.")
server.server_close()
if __name__ == "__main__":
main()
# -*- coding: utf-8 -*-
"""
Mochi French & Anki Standalone Web Server
Học từ vựng trên trình duyệt từ mọi thiết bị (PC, Điện thoại, Tablet) qua Wi-Fi LAN hoặc Internet 4G/5G
Không cần mở Anki Desktop, không cần cài AnkiDroid.
"""
import os
import sys
import re
import html
import json
import time
import shutil
import socket
import sqlite3
import random
import mimetypes
import threading
import subprocess
import urllib.parse
import urllib.request
from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
# Ensure UTF-8 console output
try:
sys.stdout.reconfigure(encoding='utf-8')
sys.stderr.reconfigure(encoding='utf-8')
except Exception:
pass
IS_CLOUD_ENV = bool(os.environ.get("SPACE_ID") or os.environ.get("RENDER") or os.environ.get("CLOUD_MODE"))
PORT = int(os.environ.get("PORT", os.environ.get("MOCHI_PORT", 7860 if IS_CLOUD_ENV else 8686)))
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
ANKI_USER_DIR = r"E:\AnkiPortable\AnkiData\User 1"
ANKI_COL_PATH = os.path.join(ANKI_USER_DIR, "collection.anki2")
LOCAL_MEDIA_DIR = os.path.join(ANKI_USER_DIR, "collection.media")
CLOUD_MEDIA_DIR = os.path.join(BASE_DIR, "collection.media")
ANKI_MEDIA_DIR = LOCAL_MEDIA_DIR if os.path.isdir(LOCAL_MEDIA_DIR) else CLOUD_MEDIA_DIR
MEDIA_PACK_TAR = os.path.join(BASE_DIR, "media_pack.tar")
SNAPSHOT_DB_PATH = os.path.join(BASE_DIR, "anki_snapshot.db")
PROGRESS_DB_PATH = os.path.join(BASE_DIR, "web_progress.db")
db_lock = threading.Lock()
tunnel_state = {
"running": False,
"public_url": None,
"status": "idle",
"proc": None,
"error": None
}
def get_lan_ip():
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.settimeout(0.5)
s.connect(("8.8.8.8", 80))
ip = s.getsockname()[0]
s.close()
return ip
except Exception:
return "127.0.0.1"
def clean_html(raw):
if not raw:
return ""
txt = str(raw)
txt = re.sub(r"\[sound:[^\]]+\]", "", txt)
txt = re.sub(r"\{\{c\d+::(.*?)(?:::.*?)?\}\}", r"\1", txt, flags=re.IGNORECASE | re.DOTALL)
txt = re.sub(r"<br\s*/?>", " ", txt, flags=re.IGNORECASE)
txt = re.sub(r"<[^>]+>", "", txt)
txt = html.unescape(txt)
txt = txt.replace("\xa0", " ").replace(" ", " ")
return re.sub(r"\s+", " ", txt).strip()
def extract_sound_filename(raw):
if not raw:
return ""
txt = str(raw).strip()
m = re.search(r"\[sound:([^\]]+)\]", txt)
if m:
return m.group(1).strip()
txt = clean_html(txt)
if txt.lower().endswith((".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac")):
return txt
return ""
def is_anki_connect_alive():
try:
with socket.create_connection(("127.0.0.1", 8765), timeout=0.12):
return True
except Exception:
return False