| |
| |
| """ |
| srt2json.py — Công cụ SRT/VTT → JSON · Tách từng câu · Dịch Nhật → Việt |
| ======================================================================= |
| |
| Pipeline: SRT / VTT → Đọc timestamp → Tách từng câu → JA + VI → JSON |
| |
| JSON đầu ra (đúng định dạng yêu cầu): |
| |
| { |
| "cues": [ |
| { |
| "s": 47.29, |
| "e": 49.79, |
| "ja": "（彼氏）はい", |
| "vi": "Vâng." |
| } |
| ] |
| } |
| |
| CÁCH DÙNG |
| --------- |
| 1) Giao diện web (khuyên dùng — chỉ cần chạy, không cần cài gì thêm): |
| |
| python srt2json.py |
| |
| → trình duyệt tự mở http://127.0.0.1:8321 |
| → kéo-thả file .srt / .vtt (hoặc JSON cũ còn câu thiếu để ĐIỀN NỐT) |
| → xem tiến độ → Tải JSON. |
| |
| 2) Dòng lệnh (CLI): |
| |
| python srt2json.py video.srt -o video.json # dịch và ghi ra file |
| python srt2json.py video.srt # in JSON ra màn hình |
| python srt2json.py video.json # ĐIỀN NỐT câu thiếu trong JSON cũ |
| python srt2json.py video.srt --workers 8 # tăng số luồng cho nhanh |
| |
| 2 ENGINE DỊCH |
| ------------- |
| * google (mặc định — online): nhanh nhất, chất lượng tốt nhất, miễn phí, |
| không cần key. Nhược điểm: gửi request qua mạng; chạy quá nhiều có thể |
| bị Google chặn tạm (tool tự chờ nguội + 4 vòng thử lại + cache giúp |
| đỡ phải dịch lại). |
| * local (offline — NLLB-200): KHÔNG cần internet, không bao giờ bị chặn, |
| dịch thẳng Nhật→Việt ngay trên máy. Chất lượng khá (hơi kém Google). |
| Cần cài 1 lần: |
| |
| pip install ctranslate2 sentencepiece huggingface_hub |
| |
| và lần chạy đầu sẽ tự tải model (~650MB) vào thư mục models/ cạnh tool. |
| Sau đó chạy offline mãi. Cần ~1.5GB RAM trống. Dùng: |
| |
| python srt2json.py video.srt --engine local |
| (trên web UI: Tuỳ chọn nâng cao → Engine dịch → Offline) |
| |
| CACHE DỊCH (mới) |
| ---------------- |
| Mọi câu đã dịch được ghi vào srt2json_cache.json cạnh tool: |
| chạy lại cùng file (hay bất kỳ file có câu trùng) gần như TỨC THÌ, |
| chế độ điền nốt cũng rẻ hơn nhiều. Tắt bằng --no-cache. |
| |
| TUỲ CHỌN CLI |
| ------------ |
| -o, --output FILE file JSON đầu ra (mặc định: in ra màn hình; |
| chế độ điền nốt: ghi đè lên file vào nếu bỏ trống) |
| --engine {google,local} engine dịch (mặc định: google) |
| --no-cache không dùng/ghi cache dịch |
| --no-translate không dịch, trường "vi" để rỗng |
| --split tách câu dài thành nhiều câu theo dấu 。！？ |
| --keep-tags giữ thẻ định dạng <i>, <font>... (mặc định: lược bỏ) |
| --workers N số luồng dịch song song, engine google (mặc định: 5) |
| --src LANG ngôn ngữ nguồn (mặc định: ja) |
| --tgt LANG ngôn ngữ đích (mặc định: vi) |
| --host HOST --port PORT cho chế độ web (mặc định 127.0.0.1:8321) |
| --no-browser không tự mở trình duyệt |
| |
| GHI CHÚ |
| ------- |
| - KHÔNG cần cài thư viện ngoài cho engine google — chỉ thư viện chuẩn Python. |
| - Dịch bằng Google Translate công khai (miễn phí) hoặc NLLB-200 offline. |
| - CHỐNG THIẾU DỊCH: ánh xạ 1-1 từng câu; nhận diện đúng bị-chặn |
| (302/429/503/trang HTML) để mọi luồng cùng nghỉ nguội; khử trùng lặp; |
| câu toàn ký hiệu giữ nguyên; tới 4 vòng thử lại; cache tái sử dụng. |
| - Mọi dữ liệu xử lý ngay trên máy bạn. |
| """ |
|
|
| import argparse |
| import json |
| import os |
| import random |
| import re |
| import sys |
| import threading |
| import time |
| import urllib.error |
| import urllib.parse |
| import urllib.request |
| import uuid |
| import webbrowser |
| from concurrent.futures import ThreadPoolExecutor |
| from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer |
|
|
| VERSION = "1.3.0" |
| DEFAULT_PORT = 8321 |
| MAX_UPLOAD = 30 * 1024 * 1024 |
|
|
| _UAS = [ |
| "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36", |
| "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0", |
| "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15", |
| "Mozilla/5.0 (X11; Linux x86_64; rv:126.0) Gecko/20100101 Firefox/126.0", |
| "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1", |
| ] |
|
|
| GTX_URL = "https://translate.googleapis.com/translate_a/single" |
| T_MAIN = "https://translate.googleapis.com/translate_a/t?" |
| T_ALT = "https://clients5.google.com/translate_a/t?" |
|
|
| |
| NLLB_REPO = "JustFrederik/nllb-200-distilled-600M-ct2-int8" |
| NLLB_LANGS = { |
| "ja": "jpn_Jpan", "vi": "vie_Latn", "en": "eng_Latn", |
| "zh": "zho_Hans", "ko": "kor_Hang", "th": "tha_Thai", |
| "id": "ind_Latn", "fr": "fra_Latn", "es": "spa_Latn", |
| "pt": "por_Latn", "ru": "rus_Cyrl", "ar": "arb_Arab", "hi": "hin_Deva", |
| } |
| LOCAL_PIP = "pip install ctranslate2 sentencepiece huggingface_hub" |
|
|
| |
| CACHE_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), |
| "srt2json_cache.json") |
|
|
|
|
| |
| |
| |
|
|
| |
| _TS = r"(?:(\d+):)?(\d{1,2}):(\d{2})[.,](\d{1,3})" |
| CUE_RE = re.compile(r"^\s*" + _TS + r"\s*-->\s*" + _TS) |
|
|
| _SENT_SPLIT_RE = re.compile(r"(?<=[。！？!?…])\s*") |
|
|
| |
| |
| _REAL_TEXT_RE = re.compile( |
| r"[A-Za-z\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uff66-\uff9f\uac00-\ud7af]") |
|
|
|
|
| class CancelledError(Exception): |
| """Người dùng đã huỷ tác vụ.""" |
|
|
|
|
| def _to_sec(h, m, s, ms): |
| ms = (ms or "0").ljust(3, "0") |
| return int(h or 0) * 3600 + int(m) * 60 + int(s) + int(ms) / 1000.0 |
|
|
|
|
| def clean_text(t, keep_tags=False): |
| """Làm sạch 1 câu: bỏ thẻ ASS {\\an8}, thẻ HTML <i>..., gộp khoảng trắng.""" |
| if not keep_tags: |
| t = re.sub(r"\{\\[^}]*\}", "", t) |
| t = re.sub(r"<[^>]+>", "", t) |
| t = re.sub(r"\s+", " ", t) |
| return t.strip() |
|
|
|
|
| def parse_subtitle(text, keep_tags=False): |
| """Đọc SRT/VTT -> danh sách cue: {"s": giây, "e": giây, "src": câu}. |
| |
| - Chịu cả BOM, CRLF, dòng số thứ tự, cue-id của VTT, NOTE/STYLE của VTT. |
| - Cue nhiều dòng được ghép thành 1 câu (nối bằng dấu cách). |
| """ |
| norm = text.replace("\r\n", "\n").replace("\r", "\n").lstrip("\ufeff") |
| lines = norm.split("\n") |
| cues = [] |
| i, n = 0, len(lines) |
| while i < n: |
| m = CUE_RE.match(lines[i]) |
| if not m: |
| i += 1 |
| continue |
| g = m.groups() |
| start = _to_sec(g[0], g[1], g[2], g[3]) |
| end = _to_sec(g[4], g[5], g[6], g[7]) |
| i += 1 |
| buf = [] |
| while i < n and lines[i].strip(): |
| buf.append(lines[i].strip()) |
| i += 1 |
| content = clean_text(" ".join(buf), keep_tags) |
| if content: |
| cues.append({"s": round(start, 2), "e": round(end, 2), |
| "src": content, "tgt": ""}) |
| return cues |
|
|
|
|
| def split_sentences(text): |
| """Tách 1 chuỗi thành các câu theo 。！？!?…""" |
| parts = [p.strip() for p in _SENT_SPLIT_RE.split(text)] |
| return [p for p in parts if p] |
|
|
|
|
| def split_long_cues(cues): |
| """Tách cue chứa nhiều câu thành nhiều cue, chia thời gian theo độ dài.""" |
| out = [] |
| for c in cues: |
| parts = split_sentences(c["src"]) if c["e"] > c["s"] else [c["src"]] |
| if len(parts) < 2: |
| out.append(c) |
| continue |
| total = sum(len(p) for p in parts) or 1 |
| dur = c["e"] - c["s"] |
| t = c["s"] |
| for k, p in enumerate(parts): |
| if k == len(parts) - 1: |
| e = c["e"] |
| else: |
| e = round(c["s"] + dur * (sum(len(x) for x in parts[:k + 1]) / total), 2) |
| if e <= t: |
| e = t |
| out.append({"s": round(t, 2), "e": e, "src": p, "tgt": ""}) |
| t = e |
| return out |
|
|
|
|
| def load_fix_json(text, src="ja", tgt="vi"): |
| """Đọc JSON đầu ra cũ -> cues (chế độ điền nốt câu thiếu). None nếu sai.""" |
| try: |
| data = json.loads(text) |
| except ValueError: |
| return None |
| if not (isinstance(data, dict) and isinstance(data.get("cues"), list) |
| and data["cues"]): |
| return None |
| cues = [] |
| for c in data["cues"]: |
| if not isinstance(c, dict) or src not in c: |
| return None |
| s = c.get("s") |
| if not isinstance(s, (int, float)): |
| return None |
| e = c.get("e", c.get("s")) |
| if not isinstance(e, (int, float)): |
| e = s |
| cues.append({"s": s, "e": e, |
| "src": str(c[src]), |
| "tgt": str(c.get(tgt, "") or "")}) |
| return cues |
|
|
|
|
| def dump_json(cues, src="ja", tgt="vi"): |
| """Xuất JSON theo đúng định dạng: {"cues":[{"s","e","ja","vi"}]}.""" |
| return json.dumps( |
| {"cues": [{"s": c["s"], "e": c["e"], |
| src: c["src"], tgt: c.get("tgt", "")} for c in cues]}, |
| ensure_ascii=False, indent=2) |
|
|
|
|
| def decode_bytes(data): |
| """Đoán encoding: UTF-8 (có/không BOM), UTF-16, Shift-JIS, EUC-JP...""" |
| if data[:2] in (b"\xff\xfe", b"\xfe\xff"): |
| try: |
| return data.decode("utf-16") |
| except UnicodeDecodeError: |
| pass |
| for enc in ("utf-8-sig", "utf-8", "shift_jis", "euc-jp"): |
| try: |
| return data.decode(enc) |
| except (UnicodeDecodeError, LookupError): |
| continue |
| return data.decode("utf-8", errors="replace") |
|
|
|
|
| |
| |
| |
|
|
| _cache_lock = threading.Lock() |
| _cache = None |
|
|
|
|
| def _cache_locked(): |
| """Nạp cache lần đầu. PHẢI đang giữ _cache_lock.""" |
| global _cache |
| if _cache is None: |
| _cache = {} |
| try: |
| with open(CACHE_PATH, encoding="utf-8") as f: |
| d = json.load(f) |
| if isinstance(d, dict): |
| _cache = d |
| except Exception: |
| _cache = {} |
| return _cache |
|
|
|
|
| def _cache_get(src, tgt, text): |
| try: |
| with _cache_lock: |
| return _cache_locked().get("%s:%s" % (src, tgt), {}).get(text) or "" |
| except Exception: |
| return "" |
|
|
|
|
| def _cache_put_many(src, tgt, pairs): |
| with _cache_lock: |
| d = _cache_locked().setdefault("%s:%s" % (src, tgt), {}) |
| for t, v in pairs: |
| if t and v: |
| d[t] = v |
|
|
|
|
| def _cache_save(): |
| with _cache_lock: |
| if _cache is None: |
| return |
| try: |
| with open(CACHE_PATH, "w", encoding="utf-8") as f: |
| json.dump(_cache, f, ensure_ascii=False) |
| except Exception: |
| pass |
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| class _Mismatch(Exception): |
| """Endpoint trả số kết quả khác số câu gửi — phải chia nhỏ lại.""" |
|
|
|
|
| class _Blocked(Exception): |
| """Bị Google chặn tạm (rate limit: 302/429/503/trang HTML sorry).""" |
|
|
|
|
| class _NoRedirect(urllib.request.HTTPRedirectHandler): |
| """Từ chối theo redirect: 302 sang trang sorry = dấu hiệu bị chặn.""" |
|
|
| def redirect_request(self, req, fp, code, msg, headers, newurl): |
| return None |
|
|
|
|
| _OPENER = urllib.request.build_opener(_NoRedirect()) |
| _BLOCK_CODES = (301, 302, 303, 307, 308, 403, 429, 503) |
|
|
|
|
| def _fetch(req, timeout=25): |
| """Thực hiện request KHÔNG theo redirect; nhận diện bị chặn.""" |
| try: |
| with _OPENER.open(req, timeout=timeout) as r: |
| body = r.read().decode("utf-8", "replace") |
| except urllib.error.HTTPError as e: |
| if e.code in _BLOCK_CODES: |
| raise _Blocked("HTTP %d" % e.code) |
| raise |
| if body.lstrip()[:1] == "<": |
| raise _Blocked("phản hồi HTML") |
| return body |
|
|
|
|
| class _Throttle(object): |
| """Nhịp chung cho engine google: |
| (1) mọi request cách nhau tối thiểu min_gap (đỡ bị chặn); |
| (2) khi bị chặn, mọi luồng cùng tạm nghỉ cho giới hạn nguội.""" |
|
|
| def __init__(self, min_gap=0.2): |
| self._lock = threading.Lock() |
| self._until = 0.0 |
| self._next_start = 0.0 |
| self._min_gap = max(0.0, min_gap) |
|
|
| def penalty(self, seconds): |
| with self._lock: |
| self._until = max(self._until, time.time() + seconds) |
|
|
| def wait(self): |
| """Đặt chỗ 1 lượt rồi chờ tới lượt đó (KHÔNG đặt lại khi chờ, |
| kẻo lượt bị tự đẩy ra xa vô hạn). Nếu đang có phạt (bị chặn) |
| thì chờ luôn cho hết phạt.""" |
| with self._lock: |
| now = time.time() |
| start = max(now, self._next_start, self._until) |
| self._next_start = start + self._min_gap |
| while True: |
| with self._lock: |
| d = max(start, self._until) - time.time() |
| if d <= 0: |
| return |
| time.sleep(min(d, 1.0)) |
|
|
| def blocked(self): |
| """True nếu đang trong đợt chặn nặng (>4s còn lại) — nên bỏ lô.""" |
| with self._lock: |
| return (self._until - time.time()) > 4.0 |
|
|
|
|
| def _gtx_post(q, src, tgt): |
| """POST tới translate_a/single (client=gtx). Trả về chuỗi đã dịch.""" |
| data = urllib.parse.urlencode( |
| {"client": "gtx", "sl": src, "tl": tgt, "dt": "t", "q": q} |
| ).encode("utf-8") |
| req = urllib.request.Request(GTX_URL, data=data, |
| headers={"User-Agent": random.choice(_UAS)}) |
| resp = json.loads(_fetch(req, timeout=30)) |
| segs = resp[0] if resp and resp[0] else [] |
| return "".join(s[0] for s in segs if s and s[0]) |
|
|
|
|
| def _t_get(qlist, src, tgt, base): |
| """GET translate_a/t (client=dict-chrome-ex): N tham số q -> N kết quả. |
| |
| Ưu điểm: kết quả nằm đúng vị trí trong mảng -> ánh xạ 1-1 chính xác. |
| """ |
| params = [("client", "dict-chrome-ex"), ("sl", src), ("tl", tgt)] |
| for q in qlist: |
| params.append(("q", q)) |
| req = urllib.request.Request(base + urllib.parse.urlencode(params), |
| headers={"User-Agent": random.choice(_UAS)}) |
| resp = json.loads(_fetch(req, timeout=25)) |
| if not isinstance(resp, list): |
| raise ValueError("translate_a/t trả định dạng lạ") |
| out = [] |
| for it in resp: |
| if isinstance(it, list): |
| it = it[0] if it else "" |
| if not isinstance(it, str): |
| raise ValueError("translate_a/t trả phần tử lạ") |
| out.append(it) |
| if len(out) != len(qlist): |
| raise _Mismatch("translate_a/t: %d != %d" % (len(out), len(qlist))) |
| return out |
|
|
|
|
| def _t_url_len(qlist): |
| """Ước lượng độ dài URL khi ghép qlist vào tham số q.""" |
| n = 140 |
| for q in qlist: |
| n += len(urllib.parse.quote(q, safe="")) + 3 |
| return n |
|
|
|
|
| def _with_retries(fn, tries=4, throttle=None): |
| """Chạy fn với retry. PHÂN BIỆT 2 loại lỗi: |
| - _Blocked (bị chặn): nộp phạt toàn cục, nghỉ nguội tăng dần; |
| - lỗi thường: backoff ngắn rồi thử lại. |
| """ |
| last = None |
| for attempt in range(tries): |
| if throttle: |
| throttle.wait() |
| try: |
| return fn() |
| except _Mismatch: |
| raise |
| except CancelledError: |
| raise |
| except _Blocked as e: |
| last = e |
| if throttle: |
| throttle.penalty(min(30.0, 1.5 * (attempt + 1) + 2.0)) |
| time.sleep(min(10.0, 1.0 + attempt) + random.random() * 0.5) |
| except Exception as e: |
| last = e |
| time.sleep(min(6.0, 0.4 * (2 ** attempt)) + random.random() * 0.3) |
| raise last or RuntimeError("không thành công") |
|
|
|
|
| def _t_multi_any(texts, src, tgt, throttle): |
| """Tầng 1: translate_a/t — xen kẽ 2 host qua các lần thử.""" |
| state = {"n": 0} |
|
|
| def fn(): |
| base = (T_MAIN, T_ALT)[state["n"] % 2] |
| state["n"] += 1 |
| return _t_get(texts, src, tgt, base) |
|
|
| return _with_retries(fn, tries=4, throttle=throttle) |
|
|
|
|
| def _gtx_join(texts, src, tgt): |
| """Ghép cả lô bằng "\\n" rồi POST 1 lần. Lệch dòng -> nêu _Mismatch.""" |
| out = _gtx_post("\n".join(texts), src, tgt) |
| lines = out.split("\n") |
| if len(lines) != len(texts): |
| raise _Mismatch("gtx: %d != %d" % (len(lines), len(texts))) |
| return [l.strip() for l in lines] |
|
|
|
|
| def _gtx_join_split(texts, src, tgt, throttle): |
| """gtx ghép dòng; nếu Google gộp dòng -> chia đôi đệ quy tìm đúng câu.""" |
| try: |
| return _with_retries(lambda: _gtx_join(texts, src, tgt), tries=2, |
| throttle=throttle) |
| except _Mismatch: |
| if len(texts) == 1: |
| return [_with_retries(lambda: _gtx_post(texts[0], src, tgt), |
| tries=3, throttle=throttle)] |
| half = len(texts) // 2 |
| return (_gtx_join_split(texts[:half], src, tgt, throttle) + |
| _gtx_join_split(texts[half:], src, tgt, throttle)) |
|
|
|
|
| def _split_for_len(text, maxlen): |
| """Câu đơn quá dài -> cắt tại ranh giới câu để vừa giới hạn request.""" |
| parts = re.split(r"(?<=[。！？!?…\n])", text) |
| chunks, cur = [], "" |
| for p in parts: |
| if not cur or len(cur) + len(p) <= maxlen: |
| cur += p |
| else: |
| chunks.append(cur) |
| cur = p |
| if cur: |
| chunks.append(cur) |
| final = [] |
| for c in chunks: |
| while len(c) > maxlen: |
| final.append(c[:maxlen]) |
| c = c[maxlen:] |
| if c: |
| final.append(c) |
| return final |
|
|
|
|
| def _translate_one(text, src, tgt, throttle): |
| """Dịch 1 câu bằng mọi cách: gtx POST -> translate_a/t (2 host).""" |
| if len(text) > 1200: |
| return "".join(_translate_one(p, src, tgt, throttle) |
| for p in _split_for_len(text, 1200)) |
| try: |
| return _with_retries(lambda: _gtx_post(text, src, tgt), tries=3, |
| throttle=throttle).replace("\n", " ").strip() |
| except Exception: |
| pass |
| for base in (T_MAIN, T_ALT): |
| try: |
| r = _with_retries(lambda b=base: _t_get([text], src, tgt, b), |
| tries=2, throttle=throttle) |
| return (r[0] or "").replace("\n", " ").strip() |
| except Exception: |
| continue |
| raise RuntimeError("không dịch được") |
|
|
|
|
| def _translate_batch(texts, src, tgt, cancel, throttle): |
| """Dịch 1 lô: 3 tầng dự phòng. Đang bị chặn nặng -> trả rỗng NGAY |
| để vòng sau (sau khi nguội) thử lại, thay vì dồn request vào chỗ chặn.""" |
| if cancel and cancel(): |
| raise CancelledError() |
|
|
| |
| if not throttle.blocked() and _t_url_len(texts) <= 1900: |
| try: |
| return _t_multi_any(texts, src, tgt, throttle) |
| except _Mismatch: |
| pass |
| except CancelledError: |
| raise |
| except Exception: |
| pass |
|
|
| |
| if not throttle.blocked(): |
| try: |
| out = _gtx_join_split(texts, src, tgt, throttle) |
| if len(out) == len(texts): |
| return out |
| except CancelledError: |
| raise |
| except Exception: |
| pass |
|
|
| |
| out = [] |
| for t in texts: |
| if cancel and cancel(): |
| raise CancelledError() |
| if throttle.blocked(): |
| out.append("") |
| continue |
| try: |
| out.append(_translate_one(t, src, tgt, throttle)) |
| except Exception: |
| out.append("") |
| time.sleep(0.1) |
| return out |
|
|
|
|
| def _build_batches(texts, todo, max_url=1500, max_items=40): |
| """Chia câu thành các lô vừa URL của translate_a/t.""" |
| batches, cur, curlen = [], [], 0 |
| for i in todo: |
| enc = len(urllib.parse.quote(texts[i], safe="")) + 3 |
| if cur and (curlen + enc > max_url or len(cur) >= max_items): |
| batches.append(cur) |
| cur, curlen = [], 0 |
| cur.append(i) |
| curlen += enc |
| if cur: |
| batches.append(cur) |
| return batches |
|
|
|
|
| |
| |
| |
| |
| |
| |
|
|
| _local_state = {"lock": threading.Lock(), "translator": None, "sp": None} |
|
|
|
|
| def _local_model_dir(): |
| return os.environ.get("SRT2JSON_MODEL_DIR") or os.path.join( |
| os.path.dirname(os.path.abspath(__file__)), "models", "nllb600") |
|
|
|
|
| def _local_ready(): |
| """Kiểm tra thư viện offline đã cài chưa. Trả về (ok, thông báo lỗi).""" |
| missing = [] |
| for mod in ("ctranslate2", "sentencepiece", "huggingface_hub"): |
| try: |
| __import__(mod) |
| except ImportError: |
| missing.append(mod) |
| if missing: |
| return False, ("Chưa cài thư viện cho chế độ Offline. Chạy lệnh:\n" |
| "pip install ctranslate2 sentencepiece huggingface_hub\n" |
| "(còn thiếu: %s)" % ", ".join(missing)) |
| return True, None |
|
|
|
|
| def _local_model_downloaded(): |
| return os.path.exists(os.path.join(_local_model_dir(), "model.bin")) |
|
|
|
|
| def _ensure_local(on_status=None): |
| """Nạp model NLLB (tự tải lần đầu ~650MB). Trả về (translator, sp).""" |
| with _local_state["lock"]: |
| if _local_state["translator"] is not None: |
| return _local_state["translator"], _local_state["sp"] |
| import ctranslate2 |
| import sentencepiece as spm |
| from huggingface_hub import snapshot_download |
|
|
| mdir = _local_model_dir() |
| if not os.path.exists(os.path.join(mdir, "model.bin")): |
| if on_status: |
| on_status() |
| snapshot_download(NLLB_REPO, local_dir=mdir) |
| if on_status: |
| on_status() |
| translator = ctranslate2.Translator(mdir, device="cpu") |
| sp = spm.SentencePieceProcessor( |
| model_file=os.path.join(mdir, "sentencepiece.bpe.model")) |
| _local_state["translator"] = translator |
| _local_state["sp"] = sp |
| return translator, sp |
|
|
|
|
| def _nllb_chunk(texts, src, tgt): |
| """Dịch 1 nhóm câu bằng NLLB offline (src/tgt là mã 2 chữ: ja, vi...).""" |
| sl = NLLB_LANGS.get(src) |
| tl = NLLB_LANGS.get(tgt) |
| if not sl or not tl: |
| raise RuntimeError("Offline chưa hỗ trợ cặp %s→%s (hỗ trợ: %s)" |
| % (src, tgt, ", ".join(sorted(NLLB_LANGS)))) |
| translator, sp = _ensure_local() |
| enc = [[sl] + sp.encode(t, out_type=str) + ["</s>"] for t in texts] |
| res = translator.translate_batch(enc, target_prefix=[[tl]] * len(texts), |
| beam_size=1, max_batch_size=8) |
| outs = [] |
| for r in res: |
| pieces = [p for p in r.hypotheses[0][1:] |
| if p not in ("</s>", "<s>", "<unk>")] |
| outs.append(sp.decode(pieces).strip()) |
| return outs |
|
|
|
|
| def _local_translate_list(texts, src, tgt, on_progress=None, cancel=None): |
| """Dịch offline danh sách câu (theo nhóm 32 câu, báo tiến độ).""" |
| results = [""] * len(texts) |
| flat = [] |
| for i, t in enumerate(texts): |
| if len(t) > 600: |
| for p in _split_for_len(t, 600): |
| flat.append((i, p)) |
| else: |
| flat.append((i, t)) |
| done = 0 |
| B = 32 |
| for c0 in range(0, len(flat), B): |
| if cancel and cancel(): |
| raise CancelledError() |
| group = flat[c0:c0 + B] |
| outs = _nllb_chunk([t for _, t in group], src, tgt) |
| for (i, _), v in zip(group, outs): |
| v = (v or "").strip() |
| results[i] = (results[i] + v).strip() if results[i] else v |
| done += len(group) |
| if on_progress: |
| on_progress(done, len(flat)) |
| return results |
|
|
|
|
| |
| |
| |
| |
| |
| |
|
|
| def translate_texts(texts, src="ja", tgt="vi", on_progress=None, |
| on_last=None, cancel=None, workers=5, |
| engine="google", use_cache=True): |
| """Dịch danh sách câu -> danh sách đã dịch (đúng thứ tự).""" |
| results = [""] * len(texts) |
| todo = [i for i, t in enumerate(texts) if t and t.strip()] |
| if not todo: |
| return results |
|
|
| |
| for i in todo: |
| if not _REAL_TEXT_RE.search(texts[i]): |
| results[i] = texts[i] |
| todo = [i for i in todo if _REAL_TEXT_RE.search(texts[i])] |
| if not todo: |
| return results |
|
|
| |
| memo = {} |
| uniq = [] |
| for i in todo: |
| t = texts[i] |
| if t not in memo: |
| memo[t] = "" |
| uniq.append(t) |
|
|
| |
| if use_cache: |
| for t in uniq: |
| v = _cache_get(src, tgt, t) |
| if v: |
| memo[t] = v |
|
|
| lock = threading.Lock() |
| counter = {"done": sum(1 for t in uniq if memo[t]), "total": len(uniq)} |
|
|
| def report(note=None): |
| if on_progress: |
| with lock: |
| d, t = counter["done"], counter["total"] |
| on_progress(d, t, note) |
|
|
| report() |
|
|
| |
| if engine == "local": |
| pending = [j for j, t in enumerate(uniq) if not memo[t]] |
| if pending: |
| def _status(): |
| report(note="model") |
|
|
| def lp(done, total): |
| if on_progress: |
| on_progress(min(done, len(pending)), len(pending), None) |
|
|
| outs = _local_translate_list([uniq[j] for j in pending], |
| src, tgt, on_progress=lp, |
| cancel=cancel) |
| for j, v in zip(pending, outs): |
| if v: |
| memo[uniq[j]] = v |
| with lock: |
| counter["done"] = sum(1 for t in uniq if memo[t]) |
| report() |
| if use_cache: |
| _cache_put_many(src, tgt, |
| [(t, memo[t]) for t in uniq if memo[t]]) |
| _cache_save() |
| for i in todo: |
| results[i] = memo.get(texts[i], "") |
| return results |
|
|
| |
| workers = max(1, min(12, int(workers or 5))) |
| throttle = _Throttle(min_gap=0.2) |
|
|
| def work(idxs, note=None): |
| if cancel and cancel(): |
| raise CancelledError() |
| batch = [uniq[j] for j in idxs] |
| out = _translate_batch(batch, src, tgt, cancel, throttle) |
| if len(out) != len(idxs): |
| out = (out + [""] * len(idxs))[:len(idxs)] |
| with lock: |
| for k, j in enumerate(idxs): |
| v = (out[k] or "").strip() |
| if v: |
| memo[uniq[j]] = v |
| counter["done"] = sum(1 for t in uniq if memo[t]) |
| if on_last and idxs: |
| j = idxs[-1] |
| on_last(uniq[j], memo[uniq[j]]) |
| report(note) |
| time.sleep(0.05 + random.random() * 0.05) |
|
|
| def run_pass(idxs, w, note): |
| batches = _build_batches(uniq, idxs) |
| if w <= 1 or len(batches) == 1: |
| for b in batches: |
| work(b, note) |
| else: |
| with ThreadPoolExecutor(max_workers=w) as pool: |
| futures = [pool.submit(work, b, note) for b in batches] |
| for f in futures: |
| f.result() |
|
|
| |
| missing = [j for j, t in enumerate(uniq) if not memo[t]] |
| if missing: |
| run_pass(missing, workers, None) |
|
|
| |
| for wait_s in (2.0, 8.0, 20.0): |
| bad = [j for j, t in enumerate(uniq) if not memo[t]] |
| if not bad: |
| break |
| time.sleep(wait_s) |
| throttle.wait() |
| report(note="retry") |
| run_pass(bad, max(1, workers // 2), "retry") |
|
|
| if use_cache: |
| _cache_put_many(src, tgt, |
| [(t, memo[t]) for t in uniq if memo[t]]) |
| _cache_save() |
|
|
| for i in todo: |
| results[i] = memo.get(texts[i], "") |
| return results |
|
|
|
|
| |
| |
| |
|
|
| _JOBS = {} |
| _JOBS_LOCK = threading.Lock() |
| _JOB_TTL = 3 * 3600 |
|
|
|
|
| class Job(object): |
| def __init__(self, cues, name, src, tgt, workers=5, fix=False, |
| engine="google", use_cache=True): |
| self.id = uuid.uuid4().hex[:12] |
| self.cues = cues |
| self.name = name |
| self.src = src |
| self.tgt = tgt |
| self.workers = workers |
| self.fix = fix |
| self.engine = engine |
| self.use_cache = use_cache |
| self.status = "translating" |
| self.total = len(cues) |
| self.done = 0 |
| self.failed = 0 |
| self.error = None |
| self.last = None |
| self.note = None |
| self.cancel = False |
| self.created = time.time() |
| self.lock = threading.Lock() |
|
|
| def snapshot(self): |
| with self.lock: |
| return {"status": self.status, "total": self.total, |
| "done": self.done, "failed": self.failed, |
| "error": self.error, "last": self.last, "note": self.note} |
|
|
|
|
| def _cleanup_jobs(): |
| now = time.time() |
| for jid in [k for k, v in _JOBS.items() if now - v.created > _JOB_TTL]: |
| _JOBS.pop(jid, None) |
|
|
|
|
| def _run_job(job): |
| try: |
| def on_progress(done, total, note=None): |
| with job.lock: |
| job.done = done |
| job.total = total |
| job.note = note |
|
|
| def on_last(src_text, tgt_text): |
| with job.lock: |
| job.last = {"ja": src_text, "vi": tgt_text} |
|
|
| if job.fix: |
| |
| missing = [i for i, c in enumerate(job.cues) if not c["tgt"]] |
| with job.lock: |
| job.total = len(missing) or 1 |
| job.done = 0 |
| if not missing: |
| with job.lock: |
| job.status = "done" |
| return |
| results = translate_texts( |
| [job.cues[i]["src"] for i in missing], job.src, job.tgt, |
| on_progress=on_progress, on_last=on_last, |
| cancel=lambda: job.cancel, workers=job.workers, |
| engine=job.engine, use_cache=job.use_cache) |
| with job.lock: |
| for k, i in enumerate(missing): |
| job.cues[i]["tgt"] = results[k] |
| job.failed = sum(1 for c in job.cues if not c["tgt"]) |
| job.status = "done" |
| else: |
| results = translate_texts( |
| [c["src"] for c in job.cues], job.src, job.tgt, |
| on_progress=on_progress, on_last=on_last, |
| cancel=lambda: job.cancel, workers=job.workers, |
| engine=job.engine, use_cache=job.use_cache) |
| with job.lock: |
| for c, v in zip(job.cues, results): |
| c["tgt"] = v |
| job.failed = sum(1 for c in job.cues if not c["tgt"]) |
| job.status = "done" |
| except CancelledError: |
| with job.lock: |
| job.status = "cancelled" |
| except Exception as e: |
| with job.lock: |
| job.status = "error" |
| job.error = ("%s: %s" % (type(e).__name__, e)) or "lỗi không rõ" |
|
|
|
|
| |
| |
| |
|
|
| SAMPLE_SRT = """1 |
| 00:00:47,290 --> 00:00:49,790 |
| （彼氏）はい |
| |
| 2 |
| 00:00:50,120 --> 00:00:53,400 |
| 今日は本当にいい天気ですね。 |
| 散歩に行きましょうよ。 |
| |
| 3 |
| 00:00:54,000 --> 00:00:56,500 |
| うん、そうだね。 |
| |
| 4 |
| 00:00:57,000 --> 00:01:00,250 |
| <i>しかし、彼は何も知らなかった…</i> |
| |
| 5 |
| 00:01:01,000 --> 00:01:03,750 |
| ちょっと待って！今行く！ |
| |
| 6 |
| 00:01:04,500 --> 00:01:08,000 |
| これはテスト用のサンプル字幕です。日本語からベトナム語へ翻訳されます。 |
| """ |
|
|
|
|
| |
| |
| |
|
|
| PAGE = r"""<!doctype html> |
| <html lang="vi"> |
| <head> |
| <meta charset="utf-8"> |
| <meta name="viewport" content="width=device-width, initial-scale=1"> |
| <title>SRT/VTT → JSON · Dịch Nhật → Việt</title> |
| <style> |
| :root{ |
| --bg:#0b1120;--card:#121b30;--card2:#0d1526;--line:#223050; |
| --text:#e7eefb;--muted:#93a5c4;--accent:#7c8cff;--accent2:#b06cff; |
| --ok:#3ddc97;--err:#ff6b6b;--warn:#ffc24b; |
| } |
| *{box-sizing:border-box} |
| [hidden]{display:none!important} |
| html,body{margin:0} |
| body{ |
| font-family:"Segoe UI",system-ui,-apple-system,"Hiragino Sans","Noto Sans",sans-serif; |
| background:radial-gradient(1100px 600px at 85% -10%,#1d2c50 0%,transparent 60%), |
| radial-gradient(900px 500px at -10% 110%,#251b4a 0%,transparent 55%),var(--bg); |
| color:var(--text);min-height:100vh; |
| } |
| .wrap{max-width:980px;margin:0 auto;padding:30px 16px 70px} |
| header{text-align:center;margin-bottom:22px} |
| .logo{font-size:40px;line-height:1} |
| h1{font-size:26px;margin:10px 0 6px;letter-spacing:.3px} |
| h1 .arrow{color:var(--accent)} |
| .sub{color:var(--muted);margin:0;font-size:14px} |
| .badge{display:inline-block;padding:1px 8px;border-radius:6px;font-size:11px;font-weight:700;vertical-align:1px} |
| .b-ja{background:#d84040;color:#fff} |
| .b-vi{background:#2f8f4e;color:#fff} |
| .card{background:linear-gradient(180deg,var(--card),var(--card2));border:1px solid var(--line);border-radius:16px;padding:20px;margin-bottom:18px;box-shadow:0 10px 30px rgba(0,0,0,.25)} |
| .tabs{display:flex;gap:8px;margin-bottom:14px} |
| .tab{flex:1;background:#0a1120;border:1px solid var(--line);color:var(--muted);padding:9px 12px;border-radius:10px;font-size:14px;cursor:pointer;transition:.15s} |
| .tab.active{color:var(--text);border-color:var(--accent);background:#152040} |
| .drop{border:2px dashed #33456e;border-radius:14px;padding:34px 16px;text-align:center;cursor:pointer;transition:.15s;background:rgba(20,30,55,.35)} |
| .drop:hover,.drop.over{border-color:var(--accent);background:rgba(30,45,80,.5)} |
| .drop-ico{font-size:34px} |
| .drop-t{font-size:15px;margin-top:6px} |
| .drop-s{color:var(--muted);font-size:12.5px;margin-top:4px} |
| .file-info{margin-top:10px;background:#0a1120;border:1px solid var(--line);border-radius:10px;padding:9px 12px;font-size:13.5px} |
| textarea{width:100%;height:170px;background:#0a1120;color:var(--text);border:1px solid var(--line);border-radius:10px;padding:10px 12px;font:13px/1.5 Consolas,Menlo,monospace;resize:vertical} |
| textarea:focus,input:focus{outline:1px solid var(--accent)} |
| select{background:#0a1120;color:var(--text);border:1px solid var(--line);border-radius:8px;padding:4px 8px;font-size:13px;margin-left:8px;vertical-align:middle} |
| .adv{margin:14px 0 4px;color:var(--muted);font-size:13.5px} |
| .adv summary{cursor:pointer;user-select:none} |
| .adv label{display:block;margin:9px 0 0 4px;cursor:pointer} |
| button{font-family:inherit} |
| .primary{display:block;width:100%;margin-top:14px;padding:13px;font-size:16px;font-weight:700;color:#fff;border:0;border-radius:12px;cursor:pointer;background:linear-gradient(90deg,var(--accent),var(--accent2));transition:.15s;box-shadow:0 6px 18px rgba(110,100,255,.35)} |
| .primary:hover{filter:brightness(1.1)} |
| .primary:disabled{opacity:.55;cursor:not-allowed} |
| .ghost{background:#0a1120;color:var(--text);border:1px solid var(--line);padding:7px 13px;border-radius:9px;font-size:13.5px;cursor:pointer;transition:.15s;margin-top:10px} |
| .ghost:hover{border-color:var(--accent)} |
| .ghost.sm{margin:0;padding:4px 10px;font-size:12.5px} |
| .err{margin-top:12px;background:rgba(255,80,80,.12);border:1px solid rgba(255,90,90,.4);color:#ffb3b3;padding:10px 12px;border-radius:10px;font-size:13.5px;white-space:pre-line} |
| .prog-head{display:flex;justify-content:space-between;align-items:center;font-size:15px;font-weight:600} |
| .bar{height:12px;background:#0a1120;border:1px solid var(--line);border-radius:99px;overflow:hidden;margin:13px 0 8px} |
| .bar>div{height:100%;width:0;background:linear-gradient(90deg,var(--accent),var(--accent2));transition:width .3s} |
| .muted{color:var(--muted);font-size:13px} |
| .last{margin-top:12px;background:#0a1120;border:1px solid var(--line);border-radius:10px;padding:10px 12px;font-size:14px} |
| .ll-ja{color:var(--muted);font-size:13px;margin-bottom:4px} |
| .ll-vi{color:var(--ok);font-weight:600} |
| .stats{display:flex;gap:10px;flex-wrap:wrap;margin-bottom:14px} |
| .chip{background:#0a1120;border:1px solid var(--line);border-radius:99px;padding:6px 14px;font-size:13px;color:var(--muted)} |
| .chip b{color:var(--text);margin-left:4px} |
| .chip.ok b{color:var(--ok)} |
| .chip.err b{color:var(--err)} |
| .actions{display:flex;gap:10px;flex-wrap:wrap} |
| .actions .primary{width:auto;margin:0;padding:11px 22px} |
| .actions .ghost{margin:0} |
| .ok-msg{color:var(--ok);margin-top:10px;font-size:13.5px} |
| .tbl-wrap{margin-top:16px;border:1px solid var(--line);border-radius:12px;overflow:auto;max-height:440px} |
| table{border-collapse:collapse;width:100%;font-size:13px;min-width:640px} |
| th{position:sticky;top:0;background:#0e1830;color:var(--muted);text-align:left;padding:9px 10px;font-size:12px;letter-spacing:.4px;border-bottom:1px solid var(--line)} |
| td{padding:8px 10px;border-bottom:1px solid #1a2740;vertical-align:top} |
| tr:nth-child(even) td{background:rgba(255,255,255,.015)} |
| td.num{color:var(--accent);font-family:Consolas,Menlo,monospace;white-space:nowrap;font-size:12.5px} |
| td.ja{color:#dbe4f5;width:34%} |
| td.vi{color:#c9f7e2} |
| tr.fail td{background:rgba(255,194,75,.07)} |
| tr.fail td.vi{color:var(--warn)} |
| footer{text-align:center;color:var(--muted);font-size:12.5px;margin-top:26px} |
| .overlay{position:fixed;inset:0;background:rgba(3,7,18,.8);display:flex;align-items:center;justify-content:center;padding:20px;z-index:50} |
| .overlay .box{width:min(880px,100%);max-height:82vh;display:flex;flex-direction:column;background:var(--card);border:1px solid var(--line);border-radius:14px;overflow:hidden} |
| .overlay .box-head{display:flex;justify-content:space-between;align-items:center;padding:12px 14px;border-bottom:1px solid var(--line);font-weight:600} |
| .overlay textarea{flex:1;min-height:52vh;border:0;border-radius:0} |
| .spin{display:inline-block;width:14px;height:14px;border:2px solid rgba(255,255,255,.4);border-top-color:#fff;border-radius:50%;animation:sp .7s linear infinite;vertical-align:-2px;margin-right:6px} |
| @keyframes sp{to{transform:rotate(360deg)}} |
| @media(max-width:600px){h1{font-size:21px}.actions{flex-direction:column}.actions .primary{width:100%}} |
| </style> |
| </head> |
| <body> |
| <div class="wrap"> |
| <header> |
| <div class="logo">🎬</div> |
| <h1>SRT / VTT <span class="arrow">→</span> JSON</h1> |
| <p class="sub">Đọc timestamp · Tách từng câu · Dịch |
| <span class="badge b-ja">JA</span> → <span class="badge b-vi">VI</span> |
| · Google (online) hoặc NLLB (offline)</p> |
| </header> |
| |
| <section class="card" id="inputCard"> |
| <div class="tabs"> |
| <button class="tab active" data-tab="file" type="button">📄 Tải file</button> |
| <button class="tab" data-tab="paste" type="button">📋 Dán văn bản</button> |
| </div> |
| |
| <div id="tab-file"> |
| <div id="drop" class="drop"> |
| <div class="drop-ico">⬇️</div> |
| <div class="drop-t">Kéo thả file <b>.srt</b> / <b>.vtt</b> vào đây, hoặc bấm để chọn</div> |
| <div class="drop-s">Hỗ trợ cả <b>JSON cũ còn câu thiếu</b> (tự điền nốt) · UTF-8 / UTF-16 / Shift-JIS</div> |
| <button class="ghost" id="btnSample" type="button">✨ Thử với file mẫu</button> |
| </div> |
| <input type="file" id="fileInput" accept=".srt,.vtt,.txt,.json" hidden> |
| <div id="fileInfo" class="file-info" hidden></div> |
| </div> |
| |
| <div id="tab-paste" hidden> |
| <textarea id="pasteBox" placeholder="Dán nội dung SRT/VTT (hoặc JSON còn câu thiếu) vào đây…" spellcheck="false"></textarea> |
| </div> |
| |
| <details class="adv"> |
| <summary>⚙️ Tuỳ chọn nâng cao</summary> |
| <label>Engine dịch: |
| <select id="optEngine"> |
| <option value="google" selected>Google (online) — nhanh, chất lượng tốt</option> |
| <option value="local">Offline (NLLB) — không cần mạng, không bị chặn, tải model 1 lần ~650MB</option> |
| </select> |
| </label> |
| <label><input type="checkbox" id="optSplit"> Tách câu dài thành nhiều câu theo dấu 。！？ (chia lại thời gian theo độ dài)</label> |
| <label><input type="checkbox" id="optTags"> Giữ thẻ định dạng (<i>, <font>…)</label> |
| <label>Tốc độ dịch Google (số luồng song song): |
| <select id="optWorkers"> |
| <option value="2">2 — chậm mà chắc (đang bị chặn thì dùng này)</option> |
| <option value="5" selected>5 — cân bằng (mặc định)</option> |
| <option value="8">8 — nhanh nhất</option> |
| </select> |
| </label> |
| </details> |
| |
| <button id="btnStart" class="primary" type="button">🚀 Bắt đầu tách & dịch</button> |
| <div id="err" class="err" hidden></div> |
| </section> |
| |
| <section class="card" id="progCard" hidden> |
| <div class="prog-head"> |
| <div id="progLabel">Đang dịch…</div> |
| <button class="ghost sm" id="btnCancel" type="button">✕ Huỷ</button> |
| </div> |
| <div class="bar"><div id="barFill"></div></div> |
| <div id="progSub" class="muted"></div> |
| <div id="lastLine" class="last" hidden></div> |
| </section> |
| |
| <section class="card" id="doneCard" hidden> |
| <div class="stats"> |
| <div class="chip">Tổng số câu<b id="stTotal">0</b></div> |
| <div class="chip ok">Dịch OK<b id="stOk">0</b></div> |
| <div class="chip err" id="stErrWrap">Bị lỗi<b id="stErr">0</b></div> |
| </div> |
| <div class="actions"> |
| <button class="primary" id="btnDownload" type="button">⬇️ Tải JSON</button> |
| <button class="ghost" id="btnCopy" type="button">📋 Copy JSON</button> |
| <button class="ghost" id="btnRaw" type="button">👁 Xem JSON</button> |
| <button class="ghost" id="btnAgain" type="button">↺ Dịch file khác</button> |
| </div> |
| <div id="copyMsg" class="ok-msg" hidden>✓ Đã copy JSON vào clipboard</div> |
| <div class="tbl-wrap"> |
| <table> |
| <thead><tr><th>#</th><th>s</th><th>e</th><th>JA</th><th>VI</th></tr></thead> |
| <tbody id="tbody"></tbody> |
| </table> |
| </div> |
| <div id="moreNote" class="muted" style="margin-top:10px"></div> |
| </section> |
| |
| <footer>srt2json.py · chạy 100% trên máy bạn · Google (online) hoặc NLLB (offline) · Ctrl+C để tắt</footer> |
| </div> |
| |
| <div class="overlay" id="rawOverlay" hidden> |
| <div class="box"> |
| <div class="box-head"><span id="rawTitle">JSON</span><button class="ghost sm" id="btnRawClose" type="button">✕ Đóng</button></div> |
| <textarea id="rawBox" readonly spellcheck="false"></textarea> |
| </div> |
| </div> |
| |
| <script> |
| var $=function(id){return document.getElementById(id)}; |
| var jobId=null,resultText='',outName='subtitles.json',pollTimer=null,curName=''; |
| |
| function esc(s){return String(s).replace(/[&<>"']/g,function(c){return{'&':'&','<':'<','>':'>','"':'"',"'":'''}[c]})} |
| function fmtSize(n){return n>1048576?(n/1048576).toFixed(1)+' MB':(n/1024).toFixed(1)+' KB'} |
| function showErr(m){var e=$('err');e.hidden=false;e.textContent=m} |
| function hideErr(){$('err').hidden=true} |
| |
| /* ---- tab Tải file / Dán văn bản ---- */ |
| Array.prototype.forEach.call(document.querySelectorAll('.tab'),function(t){ |
| t.addEventListener('click',function(){ |
| Array.prototype.forEach.call(document.querySelectorAll('.tab'),function(x){x.classList.remove('active')}); |
| t.classList.add('active'); |
| var isFile=t.getAttribute('data-tab')==='file'; |
| $('tab-file').hidden=!isFile; |
| $('tab-paste').hidden=isFile; |
| }); |
| }); |
| |
| /* ---- kéo thả file ---- */ |
| var file=null; |
| var drop=$('drop'),fileInput=$('fileInput'); |
| drop.addEventListener('click',function(e){if(e.target.id!=='btnSample')fileInput.click()}); |
| fileInput.addEventListener('change',function(){setFile(fileInput.files[0])}); |
| ['dragenter','dragover'].forEach(function(ev){drop.addEventListener(ev,function(e){e.preventDefault();e.stopPropagation();drop.classList.add('over')})}); |
| ['dragleave','drop'].forEach(function(ev){drop.addEventListener(ev,function(e){e.preventDefault();e.stopPropagation();drop.classList.remove('over')})}); |
| drop.addEventListener('drop',function(e){setFile(e.dataTransfer.files[0])}); |
| window.addEventListener('dragover',function(e){e.preventDefault()}); |
| window.addEventListener('drop',function(e){e.preventDefault()}); |
| |
| function setFile(f){ |
| file=f;fileInput.value=f?f.name:''; |
| var info=$('fileInfo'); |
| if(!f){info.hidden=true;info.textContent='';return} |
| info.hidden=false; |
| info.innerHTML='📄 <b>'+esc(f.name)+'</b> · '+fmtSize(f.size)+' · <span style="color:var(--ok)">sẵn sàng ✓</span>'; |
| } |
| |
| $('btnSample').addEventListener('click',function(e){ |
| e.stopPropagation(); |
| fetch('/api/sample').then(function(r){return r.text()}).then(function(t){ |
| try{setFile(new File([t],'sample.ja.srt',{type:'text/plain'}))} |
| catch(err){$('pasteBox').value=t;document.querySelector('.tab[data-tab="paste"]').click()} |
| }).catch(function(){showErr('Không tải được file mẫu.')}); |
| }); |
| |
| /* ---- bắt đầu ---- */ |
| $('btnStart').addEventListener('click',start); |
| |
| function lockUI(on){ |
| var b=$('btnStart'); |
| b.disabled=on; |
| b.innerHTML=on?'<span class="spin"></span>Đang xử lý…':'🚀 Bắt đầu tách & dịch'; |
| } |
| |
| function start(){ |
| hideErr(); |
| var isFileMode=!$('tab-file').hidden; |
| var proceed=function(body,name){ |
| curName=name; |
| var qs=new URLSearchParams({ |
| name:name, |
| split:$('optSplit').checked?'1':'0', |
| tags:$('optTags').checked?'1':'0', |
| workers:$('optWorkers').value, |
| engine:$('optEngine').value |
| }); |
| lockUI(true); |
| $('doneCard').hidden=true; |
| $('progCard').hidden=false; |
| $('lastLine').hidden=true; |
| setProgress(0,0,'Đang phân tích file…'); |
| fetch('/api/upload?'+qs.toString(),{method:'POST',body:body}) |
| .then(function(r){return r.json().then(function(d){if(!r.ok)throw new Error(d.error||('HTTP '+r.status));return d})}) |
| .then(function(d){ |
| jobId=d.job_id; |
| outName=(d.name||'subtitles').replace(/\.(srt|vtt|txt|json)$/i,'')+'.json'; |
| setProgress(0,d.total,d.fix?'Đang điền nốt các câu thiếu…':'Đang dịch…'); |
| poll(); |
| }) |
| .catch(function(e){ |
| showErr('Lỗi: '+e.message); |
| resetAfterRun(); |
| }); |
| }; |
| if(isFileMode){ |
| if(!file){showErr('Hãy chọn file .srt / .vtt trước (hoặc bấm “Thử với file mẫu”).');return} |
| file.arrayBuffer().then(function(buf){proceed(buf,file.name)}); |
| }else{ |
| var t=$('pasteBox').value.trim(); |
| if(!t){showErr('Hãy dán nội dung phụ đề vào ô văn bản.');return} |
| proceed(new TextEncoder().encode(t),'pasted.srt'); |
| } |
| } |
| |
| function setProgress(done,total,label){ |
| var pct=total?Math.round(done*100/total):0; |
| $('barFill').style.width=pct+'%'; |
| $('progLabel').innerHTML='<span class="spin"></span>'+esc(label); |
| $('progSub').textContent=(curName?curName+' · ':'')+(total?(done+' / '+total+' câu · '+pct+'%'):''); |
| } |
| |
| function poll(){ |
| fetch('/api/progress?job='+jobId).then(function(r){return r.json()}).then(function(p){ |
| if(p.status==='translating'||p.status==='queued'){ |
| var lbl='Đang dịch…'; |
| if(p.note==='retry') lbl='Đang dịch lại các câu còn lỗi (chờ hết bị chặn)…'; |
| else if(p.note==='model') lbl='Đang tải/nạp model offline lần đầu (~650MB, chỉ 1 lần)…'; |
| setProgress(p.done,p.total,lbl); |
| if(p.last){ |
| $('lastLine').hidden=false; |
| $('lastLine').innerHTML='<div class="ll-ja">'+esc(p.last.ja)+'</div><div class="ll-vi">'+esc(p.last.vi)+'</div>'; |
| } |
| pollTimer=setTimeout(poll,700); |
| }else if(p.status==='done'){ |
| finish(); |
| }else if(p.status==='cancelled'){ |
| resetAfterRun();showErr('Đã huỷ tác vụ.'); |
| }else{ |
| resetAfterRun();showErr('Lỗi: '+(p.error||'không rõ')); |
| } |
| }).catch(function(){ |
| resetAfterRun();showErr('Mất kết nối tới máy chủ (máy chủ đã tắt?).'); |
| }); |
| } |
| |
| function finish(){ |
| fetch('/api/result?job='+jobId).then(function(r){return r.text()}).then(function(t){ |
| resultText=t; |
| var cues=[];try{cues=JSON.parse(t).cues||[]}catch(e){} |
| $('stTotal').textContent=cues.length; |
| var ok=0;cues.forEach(function(c){if(c.vi&&c.vi.trim())ok++}); |
| $('stOk').textContent=ok; |
| var bad=cues.length-ok; |
| $('stErr').textContent=bad; |
| $('stErrWrap').style.display=bad?'':'none'; |
| var tb=$('tbody');tb.innerHTML=''; |
| var MAX=400; |
| cues.slice(0,MAX).forEach(function(c,i){ |
| var tr=document.createElement('tr'); |
| if(!c.vi||!c.vi.trim())tr.className='fail'; |
| tr.innerHTML='<td class="num">'+(i+1)+'</td><td class="num">'+c.s+'</td><td class="num">'+c.e+ |
| '</td><td class="ja">'+esc(c.ja)+'</td><td class="vi">'+esc(c.vi||'⚠ chưa dịch được')+'</td>'; |
| tb.appendChild(tr); |
| }); |
| $('moreNote').textContent=cues.length>MAX?('Hiển thị '+MAX+' / '+cues.length+' câu — bấm “Tải JSON” để có đầy đủ.'):''; |
| $('progCard').hidden=true; |
| $('doneCard').hidden=false; |
| $('doneCard').scrollIntoView({behavior:'smooth'}); |
| lockUI(false); |
| }).catch(function(){ |
| resetAfterRun();showErr('Không tải được kết quả.'); |
| }); |
| } |
| |
| function resetAfterRun(){ |
| clearTimeout(pollTimer); |
| $('progCard').hidden=true; |
| lockUI(false); |
| } |
| |
| $('btnCancel').addEventListener('click',function(){ |
| if(jobId)fetch('/api/cancel?job='+jobId,{method:'POST'}).catch(function(){}); |
| }); |
| |
| $('btnDownload').addEventListener('click',function(){ |
| if(!resultText)return; |
| var blob=new Blob([resultText],{type:'application/json;charset=utf-8'}); |
| var a=document.createElement('a'); |
| a.href=URL.createObjectURL(blob);a.download=outName; |
| document.body.appendChild(a);a.click();a.remove(); |
| setTimeout(function(){URL.revokeObjectURL(a.href)},5000); |
| }); |
| |
| function flashCopy(){var m=$('copyMsg');m.hidden=false;setTimeout(function(){m.hidden=true},2000)} |
| |
| $('btnCopy').addEventListener('click',function(){ |
| if(!resultText)return; |
| if(navigator.clipboard&&navigator.clipboard.writeText){ |
| navigator.clipboard.writeText(resultText).then(flashCopy,function(){legacyCopy()}); |
| }else{legacyCopy()} |
| }); |
| |
| function legacyCopy(){ |
| var ta=document.createElement('textarea'); |
| ta.value=resultText;ta.style.position='fixed';ta.style.opacity='0'; |
| document.body.appendChild(ta);ta.focus();ta.select(); |
| var ok=false;try{ok=document.execCommand('copy')}catch(e){} |
| ta.remove(); |
| if(ok)flashCopy();else showRaw(); |
| } |
| |
| function showRaw(){ |
| if(!resultText)return; |
| $('rawTitle').textContent=outName; |
| $('rawBox').value=resultText; |
| $('rawOverlay').hidden=false; |
| } |
| $('btnRaw').addEventListener('click',showRaw); |
| $('btnRawClose').addEventListener('click',function(){$('rawOverlay').hidden=true}); |
| $('rawOverlay').addEventListener('click',function(e){if(e.target===this)$('rawOverlay').hidden=true}); |
| |
| $('btnAgain').addEventListener('click',function(){ |
| $('doneCard').hidden=true;$('tbody').innerHTML='';resultText='';jobId=null; |
| setFile(null);$('pasteBox').value=''; |
| window.scrollTo({top:0,behavior:'smooth'}); |
| }); |
| </script> |
| </body> |
| </html> |
| """ |
|
|
|
|
| |
| |
| |
|
|
| def _get_job(qs): |
| jid = (qs.get("job") or [""])[0] |
| with _JOBS_LOCK: |
| return _JOBS.get(jid) |
|
|
|
|
| class Handler(BaseHTTPRequestHandler): |
| server_version = "srt2json/" + VERSION |
| protocol_version = "HTTP/1.1" |
|
|
| |
| def _query(self): |
| return urllib.parse.urlsplit(self.path) |
|
|
| def _qs(self): |
| return urllib.parse.parse_qs(self._query().query) |
|
|
| def _reply(self, code, obj, ctype="application/json; charset=utf-8", extra=None): |
| if isinstance(obj, (dict, list)): |
| body = json.dumps(obj, ensure_ascii=False).encode("utf-8") |
| elif isinstance(obj, str): |
| body = obj.encode("utf-8") |
| else: |
| body = obj |
| self.send_response(code) |
| self.send_header("Content-Type", ctype) |
| self.send_header("Content-Length", str(len(body))) |
| self.send_header("Cache-Control", "no-store") |
| self.send_header("Access-Control-Allow-Origin", "*") |
| for k, v in (extra or {}).items(): |
| self.send_header(k, v) |
| self.end_headers() |
| try: |
| self.wfile.write(body) |
| except (BrokenPipeError, ConnectionResetError): |
| pass |
|
|
| def do_OPTIONS(self): |
| self.send_response(204) |
| self.send_header("Access-Control-Allow-Origin", "*") |
| self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS") |
| self.send_header("Access-Control-Allow-Headers", "*") |
| self.send_header("Content-Length", "0") |
| self.end_headers() |
|
|
| def log_message(self, fmt, *args): |
| pass |
|
|
| |
| def do_GET(self): |
| try: |
| path = self._query().path |
| qs = self._qs() |
| if path == "/": |
| self._reply(200, PAGE, "text/html; charset=utf-8") |
| elif path == "/api/sample": |
| self._reply(200, SAMPLE_SRT, "text/plain; charset=utf-8") |
| elif path == "/api/progress": |
| job = _get_job(qs) |
| if not job: |
| self._reply(404, {"error": "không tìm thấy job (có thể đã quá cũ)"}) |
| return |
| snap = job.snapshot() |
| snap["percent"] = round(job.done * 100 / job.total) if job.total else 0 |
| self._reply(200, snap) |
| elif path == "/api/result": |
| job = _get_job(qs) |
| if not job: |
| self._reply(404, {"error": "không tìm thấy job"}) |
| return |
| if job.status != "done": |
| self._reply(409, {"error": "chưa hoàn tất (trạng thái: %s)" % job.status}) |
| return |
| payload = dump_json(job.cues, job.src, job.tgt) |
| extra = None |
| if qs.get("dl"): |
| fname = os.path.splitext(job.name)[0] + ".json" |
| try: |
| safe = fname.encode("ascii").decode("ascii") |
| except UnicodeEncodeError: |
| safe = "subtitles.json" |
| extra = {"Content-Disposition": |
| "attachment; filename=\"%s\"; filename*=UTF-8''%s" |
| % (safe, urllib.parse.quote(fname))} |
| self._reply(200, payload, "application/json; charset=utf-8", extra) |
| else: |
| self._reply(404, {"error": "not found"}) |
| except (BrokenPipeError, ConnectionResetError): |
| pass |
| except Exception as e: |
| try: |
| self._reply(500, {"error": str(e)}) |
| except Exception: |
| pass |
|
|
| |
| def do_POST(self): |
| try: |
| path = self._query().path |
| qs = self._qs() |
|
|
| if path == "/api/cancel": |
| job = _get_job(qs) |
| if job: |
| with job.lock: |
| job.cancel = True |
| self._reply(200, {"ok": True}) |
| else: |
| self._reply(404, {"ok": False}) |
| return |
|
|
| if path != "/api/upload": |
| self._reply(404, {"error": "not found"}) |
| return |
|
|
| try: |
| length = int(self.headers.get("Content-Length") or 0) |
| except ValueError: |
| length = 0 |
| if length <= 0: |
| self._reply(400, {"error": "Không có dữ liệu."}) |
| return |
| if length > MAX_UPLOAD: |
| self._reply(413, {"error": "File quá lớn (tối đa 30 MB)."}) |
| return |
| body = self.rfile.read(length) |
|
|
| name = os.path.basename((qs.get("name") or ["subtitle.srt"])[0]) or "subtitle.srt" |
| keep_tags = (qs.get("tags") or ["0"])[0].lower() in ("1", "true", "yes") |
| do_split = (qs.get("split") or ["0"])[0].lower() in ("1", "true", "yes") |
| src = (qs.get("src") or ["ja"])[0] or "ja" |
| tgt = (qs.get("tgt") or ["vi"])[0] or "vi" |
| engine = (qs.get("engine") or ["google"])[0].lower() |
| if engine not in ("google", "local"): |
| engine = "google" |
| try: |
| workers = int((qs.get("workers") or ["5"])[0]) |
| except ValueError: |
| workers = 5 |
| workers = max(1, min(12, workers)) |
|
|
| if engine == "local": |
| ok, msg = _local_ready() |
| if not ok: |
| self._reply(400, {"error": msg}) |
| return |
|
|
| text = decode_bytes(body) |
|
|
| |
| fix_mode = False |
| st = text.lstrip() |
| if name.lower().endswith(".json") or st[:1] == "{": |
| cues = load_fix_json(text, src, tgt) |
| if cues is None: |
| self._reply(400, {"error": "File JSON không đúng định dạng {\"cues\":[...]} " |
| "(cần có s, e và khóa \"%s\" trong mỗi cue)." % src}) |
| return |
| fix_mode = True |
| else: |
| cues = parse_subtitle(text, keep_tags=keep_tags) |
| if do_split: |
| cues = split_long_cues(cues) |
| if not cues: |
| self._reply(400, {"error": "Không tìm thấy dòng timestamp nào — file có phải SRT/VTT không?"}) |
| return |
|
|
| job = Job(cues, name, src, tgt, workers=workers, fix=fix_mode, |
| engine=engine) |
| with _JOBS_LOCK: |
| _cleanup_jobs() |
| _JOBS[job.id] = job |
| threading.Thread(target=_run_job, args=(job,), daemon=True).start() |
| missing = sum(1 for c in cues if not c["tgt"]) if fix_mode else job.total |
| self._reply(200, {"job_id": job.id, "total": job.total, |
| "name": job.name, "fix": fix_mode, |
| "missing": missing, "engine": engine}) |
| except (BrokenPipeError, ConnectionResetError): |
| pass |
| except Exception as e: |
| try: |
| self._reply(500, {"error": str(e)}) |
| except Exception: |
| pass |
|
|
|
|
| |
| |
| |
|
|
| def cli_run(args): |
| try: |
| with open(args.input, "rb") as f: |
| raw = f.read() |
| except OSError as e: |
| sys.exit("Không đọc được file: %s" % e) |
|
|
| text = decode_bytes(raw) |
| err = sys.stderr |
| fix_mode = False |
|
|
| if args.input.lower().endswith(".json") or text.lstrip()[:1] == "{": |
| cues = load_fix_json(text, args.src, args.tgt) |
| if cues is None: |
| sys.exit("File JSON không đúng định dạng {\"cues\":[...]} — kiểm tra lại file đầu vào.") |
| fix_mode = True |
| else: |
| cues = parse_subtitle(text, keep_tags=args.keep_tags) |
| if args.split: |
| cues = split_long_cues(cues) |
| if not cues: |
| sys.exit("Không tìm thấy dòng timestamp nào — file có phải SRT/VTT không?") |
|
|
| if args.engine == "local": |
| ok, msg = _local_ready() |
| if not ok: |
| sys.exit(msg) |
| if not _local_model_downloaded(): |
| print("Lần đầu dùng offline: tự tải model NLLB ~650MB vào thư mục " |
| "models/ (chỉ 1 lần duyệt)…", file=err) |
|
|
| |
| _plock = threading.Lock() |
|
|
| def on_progress(done, total, note=None): |
| pct = done * 100 // total if total else 0 |
| if note == "model": |
| tag = "chuẩn bị model offline" |
| elif note == "retry": |
| tag = "vòng sau, lấy lại câu lỗi" |
| else: |
| tag = "dịch" |
| with _plock: |
| err.write("\r %s: %d / %d (%d%%)" % (tag, done, total, pct)) |
| err.flush() |
|
|
| engine_name = "OFFLINE (NLLB)" if args.engine == "local" else \ |
| "Google Translate (online, %d luồng)" % args.workers |
|
|
| if fix_mode: |
| missing = [i for i, c in enumerate(cues) if not c["tgt"]] |
| print("Chế độ ĐIỀN NỐT: %d/%d câu còn thiếu tiếng Việt." |
| % (len(missing), len(cues)), file=err) |
| if not missing: |
| print("✓ File đã đủ — không cần làm gì.", file=err) |
| return |
| print("Đang dịch lại %d câu thiếu bằng %s…" % (len(missing), engine_name), file=err) |
| try: |
| results = translate_texts([cues[i]["src"] for i in missing], |
| args.src, args.tgt, |
| on_progress=on_progress, |
| workers=args.workers, |
| engine=args.engine, |
| use_cache=not args.no_cache) |
| except KeyboardInterrupt: |
| sys.exit("\nĐã huỷ.") |
| err.write("\n") |
| for k, i in enumerate(missing): |
| cues[i]["tgt"] = results[k] |
| failed = sum(1 for c in cues if not c["tgt"]) |
| if failed: |
| print("⚠ Vẫn còn %d câu trống — chạy lại lệnh này sau 1-2 phút." % failed, file=err) |
| elif not args.no_translate: |
| print("Đã đọc %d câu từ %s" % (len(cues), os.path.basename(args.input)), file=err) |
| print("Đang dịch %s → %s bằng %s…" % (args.src, args.tgt, engine_name), file=err) |
| try: |
| results = translate_texts([c["src"] for c in cues], args.src, args.tgt, |
| on_progress=on_progress, |
| workers=args.workers, |
| engine=args.engine, |
| use_cache=not args.no_cache) |
| except KeyboardInterrupt: |
| sys.exit("\nĐã huỷ.") |
| err.write("\n") |
| for c, v in zip(cues, results): |
| c["tgt"] = v |
| failed = sum(1 for c in cues if not c["tgt"]) |
| if failed: |
| print("⚠ %d câu không dịch được — có thể bị Google chặn tạm. " |
| "Chờ 1-2 phút rồi chạy: python srt2json.py <file-json> để điền nốt, " |
| "hoặc dùng --engine local (offline, không bao giờ bị chặn)." % failed, file=err) |
| else: |
| print("Đã đọc %d câu (không dịch)." % len(cues), file=err) |
|
|
| payload = dump_json(cues, args.src, args.tgt) |
| if args.output: |
| out_path = args.output |
| elif fix_mode: |
| out_path = args.input |
| else: |
| out_path = None |
| if out_path: |
| with open(out_path, "w", encoding="utf-8") as f: |
| f.write(payload + "\n") |
| print("✓ Đã ghi: %s" % out_path, file=err) |
| else: |
| print(payload) |
|
|
|
|
| |
| |
| |
|
|
| def serve(args): |
| port = args.port |
| server = None |
| for _ in range(30): |
| try: |
| server = ThreadingHTTPServer((args.host, port), Handler) |
| break |
| except OSError: |
| port += 1 |
| if server is None: |
| sys.exit("Không mở được cổng %d–%d. Thử --port khác." % (args.port, args.port + 29)) |
|
|
| display_host = "127.0.0.1" if args.host in ("0.0.0.0", "") else args.host |
| url = "http://%s:%d" % (display_host, port) |
| print("=" * 56) |
| print(" 🎬 srt2json v%s — SRT/VTT → JSON · Dịch Nhật → Việt" % VERSION) |
| print("=" * 56) |
| print(" ➜ Mở trình duyệt: %s" % url) |
| if args.host == "0.0.0.0": |
| print(" (đang lắng nghe trên mọi giao diện mạng LAN)") |
| print(" ➜ Engine: Google (online) · Offline (NLLB) — chọn trong web UI") |
| print(" ➜ Tắt máy chủ: nhấn Ctrl+C") |
| print() |
| if not args.no_browser: |
| threading.Timer(0.7, lambda: webbrowser.open(url)).start() |
| try: |
| server.serve_forever() |
| except KeyboardInterrupt: |
| print("\nĐã tắt máy chủ. Tạm biệt!") |
| finally: |
| server.server_close() |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser( |
| prog="srt2json.py", |
| description="SRT/VTT → JSON · đọc timestamp · tách từng câu · dịch Nhật → Việt " |
| "(Google Translate online hoặc NLLB offline, miễn phí). " |
| "Chạy KHÔNG có đối số để mở giao diện web. " |
| "Đưa file JSON cũ vào để ĐIỀN NỐT các câu còn thiếu.", |
| epilog="Ví dụ:\n" |
| " python srt2json.py # mở giao diện web\n" |
| " python srt2json.py video.srt -o out.json # dịch rồi ghi file\n" |
| " python srt2json.py video.srt --engine local # dịch OFFLINE (NLLB)\n" |
| " python srt2json.py out.json # điền nốt câu thiếu\n" |
| " python srt2json.py video.srt --workers 8 # google nhanh hơn\n", |
| formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("input", nargs="?", help="file .srt / .vtt (bỏ trống để chạy web UI); " |
| "đưa file .json để điền nốt câu thiếu") |
| ap.add_argument("-o", "--output", help="file JSON đầu ra (mặc định: in ra màn hình; " |
| "chế độ điền nốt: ghi đè file vào)") |
| ap.add_argument("--engine", choices=("google", "local"), default="google", |
| help="engine dịch: google (online, mặc định) hoặc local " |
| "(offline NLLB, cần: pip install ctranslate2 sentencepiece huggingface_hub)") |
| ap.add_argument("--no-cache", action="store_true", |
| help="không dùng/ghi cache dịch trên đĩa") |
| ap.add_argument("--no-translate", action="store_true", help="chỉ tách câu, không dịch") |
| ap.add_argument("--split", action="store_true", |
| help="tách câu dài thành nhiều câu theo 。！？") |
| ap.add_argument("--keep-tags", action="store_true", |
| help="giữ thẻ định dạng <i>, <font>...") |
| ap.add_argument("--workers", type=int, default=5, |
| help="số luồng song song cho engine google (mặc định: 5)") |
| ap.add_argument("--src", default="ja", help="ngôn ngữ nguồn (mặc định: ja)") |
| ap.add_argument("--tgt", default="vi", help="ngôn ngữ đích (mặc định: vi)") |
| ap.add_argument("--host", default="127.0.0.1", help="host cho web UI (mặc định: 127.0.0.1)") |
| ap.add_argument("--port", type=int, default=DEFAULT_PORT, |
| help="cổng cho web UI (mặc định: %d)" % DEFAULT_PORT) |
| ap.add_argument("--no-browser", action="store_true", help="không tự mở trình duyệt") |
| args = ap.parse_args() |
|
|
| if args.input: |
| cli_run(args) |
| else: |
| serve(args) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
