Update

Author: Zenlua

.github/module/termux/py/check_changes.py

@@ -1,100 +1,179 @@
 #!/data/data/com.tool.tree/files/home/termux/bin/python
 
+# Tóm tắt:
+# Script kiểm tra các thay đổi của file trong thư mục lớn trên Android/Termux.
+# - Dùng ThreadPoolExecutor (không sử dụng multiprocessing.SemLock).
+# - Quét file theo luồng (generator) để giảm tiêu thụ bộ nhớ.
+# - Lưu kết quả hash, kích thước, thời gian chỉnh sửa vào file JSON.
+# - Bỏ qua hash file khi kích thước và thời gian không đổi (tiết kiệm thời gian).
+# - Đọc file với bộ đệm 1 MB.
+# - Số luồng tối đa mặc định: min(32, CPU*2). Cho phép cấu hình qua tùy chọn --workers.
+# - Loại trừ đuôi file mặc định: .bak, .tmp, .log. Có thể tùy chỉnh qua --exclude.
+# - Có tùy chọn --force để tính toán lại tất cả file.
+# - Lưu file database một cách nguyên tử (ghi vào tạm rồi replace).
+# - Xử lý đường dẫn Unicode và lỗi I/O một cách chắc chắn.
+# - In ra thay đổi theo định dạng: new:, fixed:, deleted:.
+# - Bảng tham số khuyến nghị:
+#     Buffer đọc      | Số luồng tối đa      | Chunk size (executor.map)
+#     1048576 (1 MB)   | min(32, CPU*2)       | 64
+#
+# Ví dụ sử dụng:
+#   python script.py /duong/dan/thu_muc data.json --exclude=.bak,.tmp --force
+
 import os
-import hashlib
+import sys
 import json
 import argparse
-import multiprocessing as mp
-
+import hashlib
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
-def compute_hash(file_path):
+def compute_hash(file_path, buffer_size=1048576):
+    """
+    Tính SHA-256 của file.
+    Trả về tuple (file_path, hexhash) hoặc (file_path, None) nếu có lỗi.
+    """
     sha256 = hashlib.sha256()
     try:
         with open(file_path, "rb") as f:
-            for chunk in iter(lambda: f.read(65536), b""):
+            while True:
+                chunk = f.read(buffer_size)
+                if not chunk:
+                    break
                 sha256.update(chunk)
         return file_path, sha256.hexdigest()
     except Exception:
         return file_path, None
 
-
 def load_hash_db(hash_db_path):
+    """
+    Đọc database JSON (nếu có) trả về dict {rel_path: {"hash":..., "size":..., "mtime":...}}.
+    """
     if os.path.exists(hash_db_path):
-        with open(hash_db_path, "r") as f:
-            return json.load(f)
+        try:
+            with open(hash_db_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return {}
     return {}
 
-
 def save_hash_db(hash_db_path, hash_db):
-    with open(hash_db_path, "w") as f:
-        json.dump(hash_db, f, indent=2)
-
-
-def collect_files(root_dir, excluded_exts):
-    files = []
-
-    for dirpath, _, filenames in os.walk(root_dir):
-        for filename in filenames:
-
-            if filename.endswith(tuple(excluded_exts)):
-                continue
-
-            path = os.path.join(dirpath, filename)
-            files.append(path)
-
-    return files
-
-
-def scan_directory(root_dir, excluded_exts):
-
-    files = collect_files(root_dir, excluded_exts)
-
-    cpu = mp.cpu_count()
-
-    current_hashes = {}
-
-    with mp.Pool(cpu) as pool:
-
-        for file_path, file_hash in pool.imap_unordered(compute_hash, files):
-
-            if file_hash:
+    """
+    Lưu database JSON một cách nguyên tử: ghi tạm, rồi replace.
+    """
+    temp_file = hash_db_path + ".tmp"
+    try:
+        with open(temp_file, "w", encoding="utf-8") as f:
+            json.dump(hash_db, f, ensure_ascii=False, indent=2)
+        os.replace(temp_file, hash_db_path)
+    except Exception as e:
+        print(f"Unable to save database hash: {e}", file=sys.stderr)
+
+def iter_files(root_dir, excluded_exts):
+    """
+    Yield đường dẫn file trong thư mục (không đệ quy).
+    Loại trừ các file có đuôi trong excluded_exts.
+    """
+    for entry in os.scandir(root_dir):
+        if not entry.is_file():
+            continue
+        name = entry.name
+        if any(name.lower().endswith(ext) for ext in excluded_exts):
+            continue
+        yield entry.path
+
+def scan_directory(root_dir, excluded_exts, previous_db, force=False, buffer_size=1048576, max_workers=None):
+    """
+    Quét thư mục, tính hash cho file mới/đã thay đổi, kết hợp với database trước đó.
+    Trả về dict mới {rel_path: {"hash":..., "size":..., "mtime":...}}.
+    """
+    current_db = {}
+    # Chuẩn bị công việc: xác định file cần hash (generator)
+    def gen_tasks():
+        for file_path in iter_files(root_dir, excluded_exts):
+            rel = os.path.relpath(file_path, root_dir)
+            try:
+                st = os.stat(file_path)
+            except Exception:
+                continue  # bỏ qua file không thể truy xuất
+            size = st.st_size
+            mtime = st.st_mtime_ns
+            prev = previous_db.get(rel)
+            if not force and prev and prev.get("size") == size and prev.get("mtime") == mtime:
+                # Không thay đổi, dùng hash cũ
+                current_db[rel] = {"hash": prev.get("hash"), "size": size, "mtime": mtime}
+            else:
+                # Cần tính hash
+                yield file_path
+
+    if max_workers is None:
+        cpu = os.cpu_count() or 1
+        max_workers = min(32, cpu * 2)
+    try:
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # executor.map với chunksize giới hạn số tasks đồng thời
+            for file_path, file_hash in executor.map(lambda p: compute_hash(p, buffer_size), gen_tasks(), chunksize=64):
                 rel = os.path.relpath(file_path, root_dir)
-                current_hashes[rel] = file_hash
-
-    return current_hashes
-
-
-def check_changes(root_dir, hash_db_path):
-
-    excluded_extensions = [".bak", ".tmp", ".log"]
-
-    previous_hashes = load_hash_db(hash_db_path)
-
-    current_hashes = scan_directory(root_dir, excluded_extensions)
-
-    for rel_path, current_hash in current_hashes.items():
-
-        if rel_path not in previous_hashes:
-            print(f"new: {rel_path}")
-
-        elif previous_hashes[rel_path] != current_hash:
-            print(f"fixed: {rel_path}")
+                try:
+                    st = os.stat(file_path)
+                    size = st.st_size
+                    mtime = st.st_mtime_ns
+                except Exception:
+                    size = None
+                    mtime = None
+                if file_hash:
+                    current_db[rel] = {"hash": file_hash, "size": size, "mtime": mtime}
+                else:
+                    current_db[rel] = {"hash": None, "size": size, "mtime": mtime}
+    except KeyboardInterrupt:
+        print("Program paused (interrupted by user)...", file=sys.stderr)
+        return current_db
+
+    return current_db
+
+def check_changes(root_dir, hash_db_path, exclude_list, force=False, buffer_size=1048576, max_workers=None):
+    """
+    So sánh thay đổi giữa hash cũ và hash mới, in ra kết quả.
+    Cập nhật và lưu database.
+    """
+    previous_db = load_hash_db(hash_db_path)
+    current_db = scan_directory(root_dir, exclude_list, previous_db, force, buffer_size, max_workers)
+
+    # In kết quả so sánh
+    for rel, info in current_db.items():
+        if rel not in previous_db:
+            print(f"new: {rel}")
+        elif previous_db.get(rel, {}).get("hash") != info.get("hash"):
+            print(f"fixed: {rel}")
+    for rel in previous_db:
+        if rel not in current_db:
+            print(f"deleted: {rel}")
+
+    # Lưu database mới
+    save_hash_db(hash_db_path, current_db)
+
+def main():
+    parser = argparse.ArgumentParser(description="Scan the directory, calculate the SHA-256 value, and check for changes.")
+    parser.add_argument("directory", help="Folder to scan")
+    parser.add_argument("hash_db", help="The path to the JSON file storing the cache hash.")
+    parser.add_argument("--exclude", default=".bak,.tmp,.log",
+                        help="Excluded file extensions (separated by commas). Default: .bak, .tmp, .log")
+    parser.add_argument("--force", action="store_true",
+                        help="Recalculate the hash for all files, without using the cache.")
+    parser.add_argument("--workers", type=int,
+                        help="Maximum number of threads (default = min(32, CPU*2))")
+    args = parser.parse_args()
 
-    for rel_path in previous_hashes:
-        if rel_path not in current_hashes:
-            print(f"deleted: {rel_path}")
+    directory = os.path.abspath(args.directory)
+    exclude_exts = [ext if ext.startswith('.') else '.'+ext for ext in (args.exclude or "").split(',') if ext.strip()]
+    if not exclude_exts:
+        exclude_exts = [".bak", ".tmp", ".log"]
 
-    save_hash_db(hash_db_path, current_hashes)
+    if not os.path.isdir(directory):
+        print(f"Paths that are not folders: {directory}", file=sys.stderr)
+        sys.exit(1)
 
+    check_changes(directory, args.hash_db, exclude_exts, force=args.force,
+                  buffer_size=1048576, max_workers=args.workers)
 
 if __name__ == "__main__":
-
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument("directory")
-
-    parser.add_argument("hash_db")
-
-    args = parser.parse_args()
-
-    check_changes(args.directory, args.hash_db)
+    main()

.github/module/termux/py/gettype.py

@@ -2,7 +2,7 @@
 
 import os
 import sys
-import multiprocessing as mp
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 formats = (
     (b'PK', "zip"),
@@ -185,7 +185,6 @@ def main(path):
     path = os.path.abspath(path)
     cache = load_cache()
 
-    # Thư mục gốc đang chạy
     if os.path.isfile(path):
         root = os.path.dirname(path)
         root = os.path.abspath(root)
@@ -204,11 +203,13 @@ def main(path):
         return
 
     valid_relpaths = set()
+    cpu = min((os.cpu_count() or 1), 4)
+    args = [(f, root, root_cache) for f in files]
 
-    cpu = min(mp.cpu_count(), 4)
-    with mp.Pool(cpu) as pool:
-        args = [(f, root, root_cache) for f in files]
-        for file, relpath, typ, mtime_ns in pool.imap_unordered(gettype, args):
+    with ThreadPoolExecutor(max_workers=cpu) as executor:
+        futures = [executor.submit(gettype, arg) for arg in args]
+        for future in as_completed(futures):
+            file, relpath, typ, mtime_ns = future.result()
             valid_relpaths.add(relpath)
             cache.setdefault(root, {})[relpath] = (typ, mtime_ns)
             print(f"{os.path.basename(file)}:{typ}")
@@ -221,4 +222,4 @@ def main(path):
     if len(sys.argv) < 2:
         print("Usage: gettype.py <file_or_directory>")
         sys.exit(1)
-    main(sys.argv[1])
+    main(sys.argv[1])