pysfi 0.1.7__py3-none-any.whl → 0.1.11__py3-none-any.whl

sfi/docscan/docscan.py

@@ -3,11 +3,13 @@
 from __future__ import annotations
 
 import argparse
+import contextlib
 import csv
 import html
 import json
 import logging
 import re
+import sys
 import threading
 import time
 import xml.etree.ElementTree as ET
@@ -62,6 +64,42 @@ try:
 except ImportError:
     pypdf = None
 
+# Language support imports
+try:
+    from sfi.docscan.lang.eng import ENGLISH_DEFAULTS as EN_TRANSLATIONS
+    from sfi.docscan.lang.zhcn import TRANSLATIONS as ZH_TRANSLATIONS
+except ImportError:
+    try:
+        from lang.eng import ENGLISH_DEFAULTS as EN_TRANSLATIONS
+        from lang.zhcn import TRANSLATIONS as ZH_TRANSLATIONS
+    except ImportError:
+        # Fallback translations if import fails
+        ZH_TRANSLATIONS = {}
+        EN_TRANSLATIONS = {}
+
+# Global language setting
+USE_CHINESE = True  # Default to Chinese
+
+
+def t(key: str, **kwargs) -> str:
+    """Get translated text for the given key.
+
+    Args:
+        key: Translation key
+        **kwargs: Arguments for string formatting
+
+    Returns:
+        Translated text
+    """
+    text = ZH_TRANSLATIONS.get(key, key) if USE_CHINESE else EN_TRANSLATIONS.get(key, key)
+
+    # Format with kwargs if provided
+    if kwargs:
+        with contextlib.suppress(KeyError, ValueError):
+            text = text.format(**kwargs)
+    return text
+
+
 logging.basicConfig(level=logging.INFO, format="%(message)s")
 logger = logging.getLogger(__name__)
 cwd = Path.cwd()
@@ -85,7 +123,7 @@ class Rule:
                 # Use re.ASCII for faster matching when possible
                 self.compiled_pattern = re.compile(self.pattern, flags | re.ASCII)
             except re.error as e:
-                logger.warning(f"Invalid regex pattern '{self.pattern}': {e}")
+                logger.warning(t("invalid_regex_pattern", pattern=self.pattern, error=e))
                 self.compiled_pattern = None
         else:
             self.compiled_pattern = None
@@ -173,6 +211,7 @@ class DocumentScanner:
         self.paused_event.set()  # Initially not paused
         self.stopped = False
         self._progress_callback = None
+        self._executor = None  # Keep reference to executor for forced shutdown
 
     def set_progress_callback(self, callback: Callable[[int, int], None]) -> None:
         """Set callback function for progress updates.
@@ -186,19 +225,18 @@ class DocumentScanner:
         """Pause the scanning process."""
         self.paused = True
         self.paused_event.clear()
-        logger.info("Scan paused")
 
     def resume(self) -> None:
         """Resume the scanning process."""
         self.paused = False
         self.paused_event.set()
-        logger.info("Scan resumed")
+        logger.info(t("scan_resumed"))
 
     def stop(self) -> None:
         """Stop the scanning process."""
         self.stopped = True
         self.paused_event.set()  # Ensure thread can exit
-        logger.info("Scan stopped")
+        logger.info(t("scan_stopped"))
 
     def is_paused(self) -> bool:
         """Check if the scanner is paused."""
@@ -222,9 +260,9 @@ class DocumentScanner:
         self.paused = False
         self.paused_event.set()
 
-        logger.info(f"Scanning directory: {self.input_dir}")
+        logger.info(t("scanning_directory", directory=str(self.input_dir)))
         files = self._collect_files()
-        logger.info(f"Found {len(files)} files to scan")
+        logger.info(t("found_files_to_scan", count=len(files)))
 
         results = {
             "scan_info": {
@@ -243,53 +281,117 @@ class DocumentScanner:
         # Scan files in parallel
         processed = 0
         executor_class = ProcessPoolExecutor if self.use_process_pool else ThreadPoolExecutor
-        with executor_class(max_workers=threads) as executor:
-            future_to_file = {executor.submit(self._scan_file_with_pause_check, file): file for file in files}
+        executor = executor_class(max_workers=threads)
+        self._executor = executor  # Keep reference for forced shutdown
 
-            for future in as_completed(future_to_file):
+        try:
+            # Submit futures one by one to respect pause state
+            submitted_futures = []
+            was_paused = False  # Track previous pause state
+
+            for file in files:
+                # Check if stopped before submitting more tasks
+                if self.stopped:
+                    logger.info(t("scan_stopped_before_submitting_tasks"))
+                    break
+
+                # Wait if paused before submitting new tasks
+                while self.paused:
+                    # Log when entering paused state
+                    if not was_paused:
+                        logger.info(t("scan_paused"))
+                        was_paused = True
+
+                    self.paused_event.wait(0.1)
+                    if self.stopped:
+                        logger.info(t("scan_stopped_while_paused"))
+                        break
+
+                # Log when exiting paused state
+                if was_paused and not self.paused:
+                    logger.info(t("scan_resumed"))
+                    was_paused = False
+
+                if self.stopped:
+                    break
+
+                future = executor.submit(self._scan_file_with_pause_check, file)
+                submitted_futures.append(future)
+
+            # Process completed futures
+            for future in as_completed(submitted_futures):
                 # Check if stopped before processing this future
                 if self.stopped:
-                    logger.info("Scan stopped by user, cancelling remaining tasks...")
+                    logger.info(t("scan_stopped_by_user_canceling_tasks"))
                     # Cancel all remaining futures
-                    for f in future_to_file:
+                    for f in submitted_futures:
                         if not f.done():
                             f.cancel()
                     break
 
-                # Wait if paused
+                # Wait if paused before processing result
                 while self.paused:
-                    time.sleep(0.1)
+                    # Log when entering paused state
+                    if not was_paused:
+                        logger.info(t("scan_paused"))
+                        was_paused = True
+
+                    self.paused_event.wait(0.1)
                     if self.stopped:
-                        logger.info("Scan stopped while paused")
+                        logger.info(t("scan_stopped_while_paused"))
                         break
 
-                file_path = future_to_file[future]
+                # Log when exiting paused state
+                if was_paused and not self.paused:
+                    logger.info(t("scan_resumed"))
+                    was_paused = False
+
+                if self.stopped:
+                    break
+
                 try:
-                    file_result = future.result()
+                    file_result = future.result(timeout=1.0)  # Short timeout to allow quick stop
                     if file_result and file_result["matches"]:
                         results["matches"].append(file_result)
-                        logger.info(f"Found matches in: {file_path.name}")
+                        logger.info(t("found_matches_in_file", file_name=Path(file_result.get("file_path", "")).name))
+                except TimeoutError:
+                    logger.warning(t("task_timeout_scan_may_be_stopping"))
+                    if self.stopped:
+                        break
                 except Exception as e:
-                    logger.error(f"Error scanning {file_path}: {e}")
+                    if not self.stopped:
+                        logger.error(t("error_scanning_file", error=e))
 
                 processed += 1
 
                 # Report progress
                 if show_progress and processed % 10 == 0:
-                    logger.info(f"Progress: {processed}/{len(files)} files processed")
+                    logger.info(t("progress_report", processed=processed, total=len(files)))
 
                 # Call progress callback if set
                 if self._progress_callback:
                     self._progress_callback(processed, len(files))
 
+        finally:
+            # Force shutdown if stopped
+            if self.stopped and self._executor:
+                logger.info(t("force_shutting_down_executor"))
+                if sys.version_info >= (3, 9):
+                    self._executor.shutdown(wait=False, cancel_futures=True)
+                else:
+                    self._executor.shutdown(wait=False)
+            else:
+                self._executor.shutdown(wait=True)
+            self._executor = None
+
         results["scan_info"]["files_with_matches"] = len(results["matches"])
         results["scan_info"]["files_processed"] = processed
         results["stopped"] = self.stopped
 
         if self.stopped:
-            logger.info(f"Scan stopped. Processed {processed} files")
+            logger.info(t("scan_stopped_processed_files", processed=processed))
         else:
-            logger.info(f"Scan complete. Found matches in {len(results['matches'])} files")
+            logger.info(t("scan_complete_found_matches", matches_count=len(results["matches"])))
 
         return results
 
@@ -299,24 +401,55 @@ class DocumentScanner:
         if self.stopped:
             return {}
 
+        # Check if paused before processing
+        while self.paused:
+            self.paused_event.wait(0.1)
+            if self.stopped:
+                return {}
+
         return self._scan_file(file_path)
 
     def _collect_files(self) -> list[Path]:
         """Collect all files matching the specified types."""
         files = []
+        image_extensions = ["jpg", "jpeg", "png", "gif", "bmp", "tiff"]
+
         for ext in self.file_types:
+            # If extension is an image format and OCR is not enabled, skip
+            if ext.lower() in image_extensions and not self.use_pdf_ocr:
+                continue
             files.extend(self.input_dir.rglob(f"*.{ext.lower()}"))
             files.extend(self.input_dir.rglob(f"*.{ext.upper()}"))
         return list(set(files))  # Remove duplicates
 
     def _scan_file(self, file_path: Path) -> dict[str, Any]:
         """Scan a single file and return matches."""
+        # Check if stopped before starting
+        if self.stopped:
+            return {}
+
+        # Check if paused before starting
+        while self.paused:
+            self.paused_event.wait(0.1)
+            if self.stopped:
+                return {}
+
         file_start_time = time.perf_counter()
         ext = file_path.suffix.lower().lstrip(".")
         text = ""
         metadata = {}
 
         try:
+            # Check if stopped before extraction
+            if self.stopped:
+                return {}
+
+            # Check if paused before extraction
+            while self.paused:
+                self.paused_event.wait(0.1)
+                if self.stopped:
+                    return {}
+
             # Route to appropriate extractor
             if ext == "pdf":
                 text, metadata = self._extract_pdf(file_path)
@@ -341,11 +474,26 @@ class DocumentScanner:
             elif ext in ["pptx", "ppt"]:
                 text, metadata = self._extract_pptx(file_path)
             elif ext in ["jpg", "jpeg", "png", "gif", "bmp", "tiff"]:
-                text, metadata = self._extract_image(file_path)
+                # Only extract images if OCR is enabled
+                if self.use_pdf_ocr:  # Using the same flag for consistency
+                    text, metadata = self._extract_image(file_path)
+                else:
+                    return {}  # Skip image files if OCR is disabled
             else:
                 text, metadata = self._extract_text(file_path)
+
+            # Check if stopped after extraction
+            if self.stopped:
+                return {}
+
+            # Check if paused after extraction
+            while self.paused:
+                self.paused_event.wait(0.1)
+                if self.stopped:
+                    return {}
+
         except Exception as e:
-            logger.warning(f"Could not extract text from {file_path}: {e}")
+            logger.warning(t("could_not_extract_text_from_file", file_path=file_path, error=e))
             return {}
 
         processing_time = time.perf_counter() - file_start_time
@@ -353,9 +501,16 @@ class DocumentScanner:
         if not text:
             return {}
 
-        # Apply all rules
+        # Apply all rules with stop check
         file_matches = []
         for rule in self.rules:
+            if self.stopped:
+                return {}
+            # Check if paused before each rule
+            while self.paused:
+                self.paused_event.wait(0.1)
+                if self.stopped:
+                    return {}
             rule_matches = rule.search(text)
             if rule_matches:
                 for match in rule_matches:
@@ -369,7 +524,15 @@ class DocumentScanner:
         # Add processing time to metadata
         metadata["processing_time_seconds"] = round(processing_time, 3)
 
-        logger.info(f"Processed {file_path.name} ({ext}) in {processing_time:.3f}s - {len(file_matches)} matches found")
+        logger.info(
+            t(
+                "processed_file_info",
+                file_name=file_path.name,
+                ext=ext,
+                time=round(processing_time, 3),
+                matches_count=len(file_matches),
+            )
+        )
 
         return {
             "file_path": str(file_path),
@@ -381,60 +544,102 @@ class DocumentScanner:
 
     def _extract_pdf(self, file_path: Path) -> tuple[str, dict[str, Any]]:
         """Extract text from PDF file with fallback."""
+        # Try PyMuPDF first (faster)
         if fitz is not None:
-            return self._extract_pdf_fitz(file_path)
-        elif pypdf is not None:
-            return self._extract_pdf_pypdf(file_path)
-        else:
-            logger.warning("No PDF library installed (pymupdf or pypdf)")
-            return "", {}
+            try:
+                return self._extract_pdf_fitz(file_path)
+            except Exception as e:
+                logger.warning(t("pymupdf_failed_for_file", file_name=file_path.name, error=e))
+
+        # Fallback to pypdf
+        if pypdf is not None:
+            try:
+                return self._extract_pdf_pypdf(file_path)
+            except Exception as e:
+                logger.error(t("pypdf_also_failed_for_file", file_name=file_path.name, error=e))
+                return "", {}
+
+        logger.warning(t("no_pdf_library_installed"))
+        return "", {}
 
     def _extract_pdf_fitz(self, file_path: Path) -> tuple[str, dict[str, Any]]:
         """Extract text from PDF using PyMuPDF (fastest method)."""
         if not fitz:
-            logger.warning("PyMuPDF not installed")
+            logger.warning(t("pymupdf_not_installed"))
             return "", {}
 
-        doc = fitz.open(str(file_path))
-        if doc.page_count == 0:
-            logger.warning(f"No pages found in {file_path}")
-            return "", {}
-        if not doc.metadata:
-            logger.warning(f"No metadata found in {file_path}")
-            return "", {}
+        doc = None
+        try:
+            doc = fitz.open(str(file_path))
+            if doc.page_count == 0:
+                logger.warning(t("no_pages_found_in_file", file_path=file_path))
+                return "", {}
+            if not doc.metadata:
+                logger.warning(t("no_metadata_found_in_file", file_path=file_path))
+                return "", {}
 
-        text_parts = []
-        metadata = {
-            "page_count": doc.page_count,
-            "title": doc.metadata.get("title", ""),
-            "author": doc.metadata.get("author", ""),
-            "subject": doc.metadata.get("subject", ""),
-            "creator": doc.metadata.get("creator", ""),
-        }
+            text_parts = []
+            metadata = {
+                "page_count": doc.page_count,
+                "title": doc.metadata.get("title", ""),
+                "author": doc.metadata.get("author", ""),
+                "subject": doc.metadata.get("subject", ""),
+                "creator": doc.metadata.get("creator", ""),
+            }
 
-        if self.use_pdf_ocr and pytesseract and Image:
-            # OCR for image-based PDFs
-            import io
+            if self.use_pdf_ocr and pytesseract and Image:
+                # OCR for image-based PDFs
+                import io
 
-            for page_num, page in enumerate(doc, 1):  # pyright: ignore[reportArgumentType]
-                pix = page.get_pixmap()
-                img_data = pix.tobytes("png")
-                image = Image.open(io.BytesIO(img_data))
-                text = pytesseract.image_to_string(image)
-                text_parts.append(f"[Page {page_num}]\n{text}")
-        else:
-            # Extract text directly (faster)
-            for page_num, page in enumerate(doc, 1):  # pyright: ignore[reportArgumentType]
-                text = page.get_text()
-                text_parts.append(f"[Page {page_num}]\n{text}")
+                for page_num, page in enumerate(doc, 1):  # pyright: ignore[reportArgumentType]
+                    # Check if stopped before processing each page
+                    if self.stopped:
+                        doc.close()
+                        return "", {}
+
+                    # Check if paused before processing each page
+                    while self.paused:
+                        self.paused_event.wait(0.1)
+                        if self.stopped:
+                            doc.close()
+                            return "", {}
+
+                    pix = page.get_pixmap()
+                    img_data = pix.tobytes("png")
+                    image = Image.open(io.BytesIO(img_data))
+                    text = pytesseract.image_to_string(image)
+                    text_parts.append(f"[Page {page_num}]\n{text}")
+            else:
+                # Extract text directly (faster)
+                for page_num, page in enumerate(doc, 1):  # pyright: ignore[reportArgumentType]
+                    # Check if stopped before processing each page
+                    if self.stopped:
+                        doc.close()
+                        return "", {}
 
-        doc.close()
-        return "\n\n".join(text_parts), metadata
+                    # Check if paused before processing each page
+                    while self.paused:
+                        self.paused_event.wait(0.1)
+                        if self.stopped:
+                            doc.close()
+                            return "", {}
+
+                    text = page.get_text()
+                    text_parts.append(f"[Page {page_num}]\n{text}")
+
+            doc.close()
+            return "\n\n".join(text_parts), metadata
+        except Exception as e:
+            if doc:
+                doc.close()
+            logger.warning(t("pymupdf_error_trying_fallback", file_path=file_path, error=e))
+            # Re-raise to trigger fallback to pypdf
+            raise
 
     def _extract_pdf_pypdf(self, file_path: Path) -> tuple[str, dict[str, Any]]:
         """Extract text from PDF using pypdf (fallback method)."""
         if not pypdf:
-            logger.warning("pypdf not installed, skipping PDF extraction")
+            logger.warning(t("pypdf_not_installed_skipping_extraction"))
             return "", {}
 
         text_parts = []
@@ -444,7 +649,7 @@ class DocumentScanner:
                 pdf_reader = pypdf.PdfReader(f)
 
                 if not pdf_reader.metadata:
-                    logger.warning(f"No metadata found in {file_path}")
+                    logger.warning(t("no_metadata_found_in_file", file_path=file_path))
                     return "", {}
 
                 metadata = {
@@ -454,11 +659,21 @@ class DocumentScanner:
                 }
 
                 for page_num, page in enumerate(pdf_reader.pages, 1):
+                    # Check if stopped before processing each page
+                    if self.stopped:
+                        return "", {}
+
+                    # Check if paused before processing each page
+                    while self.paused:
+                        self.paused_event.wait(0.1)
+                        if self.stopped:
+                            return "", {}
+
                     text = page.extract_text()
                     text_parts.append(f"[Page {page_num}]\n{text}")
 
         except Exception as e:
-            logger.warning(f"Error extracting PDF with pypdf: {e}")
+            logger.warning(t("error_extracting_pdf_with_pypdf", error=e))
             return "", {}
 
         return "\n\n".join(text_parts), metadata
@@ -466,7 +681,7 @@ class DocumentScanner:
     def _extract_odt(self, file_path: Path) -> tuple[str, dict[str, Any]]:
         """Extract text from ODT (OpenDocument Text) file."""
         if odf_odt is None:
-            logger.warning("odfpy not installed, skipping ODT extraction")
+            logger.warning(t("odfpy_not_installed_skipping_extraction"))
             return "", {}
 
         try:
@@ -479,7 +694,7 @@ class DocumentScanner:
 
             return text, metadata
         except Exception as e:
-            logger.warning(f"Error extracting ODT: {e}")
+            logger.warning(t("error_extracting_odt", error=e))
             return "", {}
 
     def _extract_rtf(self, file_path: Path) -> tuple[str, dict[str, Any]]:
@@ -514,13 +729,13 @@ class DocumentScanner:
 
             return text, metadata
         except Exception as e:
-            logger.warning(f"Error extracting RTF: {e}")
+            logger.warning(t("error_extracting_rtf", error=e))
             return "", {}
 
     def _extract_epub(self, file_path: Path) -> tuple[str, dict[str, Any]]:
         """Extract text from EPUB (ebook) file."""
         if ebooklib is None:
-            logger.warning("ebooklib not installed, skipping EPUB extraction")
+            logger.warning(t("ebooklib_not_installed_skipping_extraction"))
             return "", {}
 
         try:
@@ -529,6 +744,16 @@ class DocumentScanner:
 
             # Extract text from all items
             for item in book.get_items():
+                # Check if stopped before processing each item
+                if self.stopped:
+                    return "", {}
+
+                # Check if paused before processing each item
+                while self.paused:
+                    self.paused_event.wait(0.1)
+                    if self.stopped:
+                        return "", {}
+
                 if item.get_type() == ebooklib.ITEM_DOCUMENT:  # pyright: ignore[reportAttributeAccessIssue]
                     # Remove HTML tags
                     html_content = item.get_content().decode("utf-8")  # pyright: ignore[reportAttributeAccessIssue]
@@ -546,7 +771,7 @@ class DocumentScanner:
 
             return "\n\n".join(text_parts), metadata
         except Exception as e:
-            logger.warning(f"Error extracting EPUB: {e}")
+            logger.warning(t("error_extracting_epub", error=e))
             return "", {}
 
     def _extract_csv(self, file_path: Path) -> tuple[str, dict[str, Any]]:
@@ -556,6 +781,16 @@ class DocumentScanner:
             with open(file_path, encoding="utf-8", errors="ignore") as f:
                 reader = csv.reader(f)
                 for row in reader:
+                    # Check if stopped periodically during row processing
+                    if self.stopped:
+                        return "", {}
+
+                    # Check if paused periodically during row processing
+                    while self.paused:
+                        self.paused_event.wait(0.1)
+                        if self.stopped:
+                            return "", {}
+
                     row_text = " | ".join(str(cell) for cell in row)
                     text_parts.append(row_text)
 
@@ -565,7 +800,7 @@ class DocumentScanner:
 
             return "\n".join(text_parts), metadata
         except Exception as e:
-            logger.warning(f"Error extracting CSV: {e}")
+            logger.warning(t("error_extracting_csv", error=e))
             return "", {}
 
     def _extract_xml(self, file_path: Path) -> tuple[str, dict[str, Any]]:
@@ -585,7 +820,7 @@ class DocumentScanner:
 
             return text, metadata
         except Exception as e:
-            logger.warning(f"Error extracting XML: {e}")
+            logger.warning(t("error_extracting_xml", error=e))
             return "", {}
 
     def _extract_html(self, file_path: Path) -> tuple[str, dict[str, Any]]:
@@ -607,7 +842,7 @@ class DocumentScanner:
 
             return text, metadata
         except Exception as e:
-            logger.warning(f"Error extracting HTML: {e}")
+            logger.warning(t("error_extracting_html", error=e))
             return "", {}
 
     def _extract_markdown(self, file_path: Path) -> tuple[str, dict[str, Any]]:
@@ -634,23 +869,43 @@ class DocumentScanner:
 
             return text, metadata
         except Exception as e:
-            logger.warning(f"Error extracting Markdown: {e}")
+            logger.warning(t("error_extracting_markdown", error=e))
             return "", {}
 
     def _extract_docx(self, file_path: Path) -> tuple[str, dict[str, Any]]:
         """Extract text from DOCX file."""
         if Document is None:
-            logger.warning("python-docx not installed, skipping DOCX extraction")
+            logger.warning(t("python_docx_not_installed_skipping_extraction"))
             return "", {}
 
         doc = Document(str(file_path))
         text_parts = []
 
         for paragraph in doc.paragraphs:
+            # Check if stopped periodically during paragraph processing
+            if self.stopped:
+                return "", {}
+
+            # Check if paused periodically during paragraph processing
+            while self.paused:
+                self.paused_event.wait(0.1)
+                if self.stopped:
+                    return "", {}
+
             text_parts.append(paragraph.text)
 
         # Extract tables
         for table in doc.tables:
+            # Check if stopped before processing each table
+            if self.stopped:
+                return "", {}
+
+            # Check if paused before processing each table
+            while self.paused:
+                self.paused_event.wait(0.1)
+                if self.stopped:
+                    return "", {}
+
             for row in table.rows:
                 row_text = " | ".join(cell.text for cell in row.cells)
                 text_parts.append(row_text)
@@ -665,16 +920,40 @@ class DocumentScanner:
     def _extract_xlsx(self, file_path: Path) -> tuple[str, dict[str, Any]]:
         """Extract text from XLSX file."""
         if load_workbook is None:
-            logger.warning("openpyxl not installed, skipping XLSX extraction")
+            logger.warning(t("openpyxl_not_installed_skipping_extraction"))
             return "", {}
 
         wb = load_workbook(file_path, read_only=True, data_only=True)
         text_parts = []
 
         for sheet_name in wb.sheetnames:
+            # Check if stopped before processing each sheet
+            if self.stopped:
+                wb.close()
+                return "", {}
+
+            # Check if paused before processing each sheet
+            while self.paused:
+                self.paused_event.wait(0.1)
+                if self.stopped:
+                    wb.close()
+                    return "", {}
+
             sheet = wb[sheet_name]
             text_parts.append(f"[Sheet: {sheet_name}]")
             for row in sheet.iter_rows(values_only=True):
+                # Check if stopped periodically during row processing
+                if self.stopped:
+                    wb.close()
+                    return "", {}
+
+                # Check if paused periodically during row processing
+                while self.paused:
+                    self.paused_event.wait(0.1)
+                    if self.stopped:
+                        wb.close()
+                        return "", {}
+
                 row_text = " | ".join(str(cell) if cell is not None else "" for cell in row)
                 if row_text.strip():
                     text_parts.append(row_text)
@@ -684,6 +963,7 @@ class DocumentScanner:
             "sheets": wb.sheetnames,
         }
 
+        wb.close()
         return "\n".join(text_parts), metadata
 
     def _extract_pptx(self, file_path: Path) -> tuple[str, dict[str, Any]]:
@@ -691,13 +971,23 @@ class DocumentScanner:
         try:
             from pptx import Presentation
         except ImportError:
-            logger.warning("python-pptx not installed, skipping PPTX extraction")
+            logger.warning(t("python_pptx_not_installed_skipping_extraction"))
             return "", {}
 
         prs = Presentation(str(file_path))
         text_parts = []
 
         for slide_num, slide in enumerate(prs.slides, 1):
+            # Check if stopped before processing each slide
+            if self.stopped:
+                return "", {}
+
+            # Check if paused before processing each slide
+            while self.paused:
+                self.paused_event.wait(0.1)
+                if self.stopped:
+                    return "", {}
+
             text_parts.append(f"[Slide {slide_num}]")
             for shape in slide.shapes:
                 if hasattr(shape, "text"):
@@ -712,7 +1002,7 @@ class DocumentScanner:
     def _extract_image(self, file_path: Path) -> tuple[str, dict[str, Any]]:
         """Extract text from image file using OCR."""
         if Image is None or pytesseract is None:
-            logger.warning("PIL or pytesseract not installed, skipping image OCR")
+            logger.warning(t("pillow_or_tesseract_not_installed_skipping_ocr"))
             return "", {}
 
         try:
@@ -727,7 +1017,7 @@ class DocumentScanner:
 
             return text, metadata
         except Exception as e:
-            logger.warning(f"Could not perform OCR on {file_path}: {e}")
+            logger.warning(t("could_not_perform_ocr_on_file", file_path=file_path, error=e))
             return "", {}
 
     def _extract_text(self, file_path: Path) -> tuple[str, dict[str, Any]]:
@@ -747,36 +1037,50 @@ class DocumentScanner:
 
 def main():
     """Main entry point for document scanner."""
-    parser = argparse.ArgumentParser(
-        description="Scan documents and extract text, images, and metadata with high performance"
-    )
-    parser.add_argument("input", type=str, nargs="?", default=str(cwd), help="Input directory")
-    parser.add_argument("-r", "--rules", type=str, default="rules.json", help="Rules file (JSON)")
-    parser.add_argument("--recursive", action="store_true", help="Scan files recursively")
+    # 首先解析语言参数，但不使用翻译
+    temp_parser = argparse.ArgumentParser(add_help=False)
+    temp_parser.add_argument("--lang", choices=["en", "zh"], default="zh")
+    temp_args, _ = temp_parser.parse_known_args()
+
+    # 设置语言
+    global USE_CHINESE
+    USE_CHINESE = temp_args.lang == "zh"
+
+    parser = argparse.ArgumentParser(description=t("document_scanner_description"))
+    parser.add_argument("input", type=str, nargs="?", default=str(cwd), help=t("input_directory_help"))
+    parser.add_argument("-r", "--rules", type=str, default="rules.json", help=t("rules_file_help"))
+    parser.add_argument("--recursive", action="store_true", help=t("recursive_help"))
     parser.add_argument(
         "-f",
         "--file-types",
-        help="File types to scan (comma-separated)",
-        default="pdf,docx,xlsx,pptx,txt,odt,rtf,epub,csv,xml,html,md",
+        help=t("file_types_help"),
+        default="pdf,docx,xlsx,pptx,txt,odt,rtf,epub,csv,xml,html,md,jpg,jpeg,png,gif,bmp,tiff",
     )
-    parser.add_argument("--use-pdf-ocr", help="Use PDF OCR for image-based PDFs", action="store_true")
+    parser.add_argument("--use-pdf-ocr", help=t("use_pdf_ocr_help"), action="store_true")
     parser.add_argument(
         "--use-process-pool",
-        help="Use process pool instead of thread pool (better for CPU-intensive tasks)",
+        help=t("use_process_pool_help"),
         action="store_true",
     )
     parser.add_argument(
         "-b",
         "--batch-size",
-        help="Number of files to process in each batch",
+        help=t("batch_size_help"),
         default=50,
         type=int,
     )
-    parser.add_argument("-t", "--threads", help="Number of threads for parallel scanning", default=4, type=int)
-    parser.add_argument("--progress", help="Show progress bar", action="store_true")
-    parser.add_argument("-v", "--verbose", help="Verbose output", action="store_true")
+    parser.add_argument("-t", "--threads", help=t("threads_help"), default=4, type=int)
+    parser.add_argument("--progress", help=t("progress_help"), action="store_true")
+    parser.add_argument("-v", "--verbose", help=t("verbose_help"), action="store_true")
+
+    # 添加语言参数
+    parser.add_argument("--lang", help=t("language_help"), choices=["en", "zh"], default="zh")
+
     args = parser.parse_args()
 
+    # 再次确认语言设置（以防万一用户在完整参数中改变了语言）
+    USE_CHINESE = args.lang == "zh"
+
     if args.verbose:
         logger.setLevel(logging.DEBUG)
 
@@ -784,9 +1088,9 @@ def main():
     # Validate input directory
     input_dir = Path(args.input)
     if not input_dir.exists() or not input_dir.is_dir():
-        logger.error(f"Input directory does not exist: {args.input}")
+        logger.error(t("input_directory_does_not_exist", input_dir=args.input))
         return
-    logger.info(f"Scanning directory: {input_dir}...")
+    logger.info(t("scanning_directory", directory=str(input_dir)))
 
     # Load rules file
     rules_file = Path(args.rules)
@@ -796,15 +1100,15 @@ def main():
         if rule_files_in_input_dir:
             rules_file = rule_files_in_input_dir[0]
         else:
-            logger.error(f"Rules file does not exist: {args.rules}")
+            logger.error(t("rules_file_does_not_exist_alt", rules_file=args.rules))
             return
-    logger.info(f"Using rules file: {rules_file}")
+    logger.info(t("using_rules_file", rules_file=str(rules_file)))
 
     try:
         with open(rules_file, encoding="utf-8") as f:
             rules_data = json.load(f)
     except json.JSONDecodeError as e:
-        logger.error(f"Invalid JSON in rules file: {e}")
+        logger.error(t("invalid_json_in_rules_file", error=e))
         return
 
     # Parse rules
@@ -814,11 +1118,11 @@ def main():
     elif isinstance(rules_data, dict) and "rules" in rules_data:
         rules = [Rule(rule) for rule in rules_data["rules"]]
     else:
-        logger.error("Invalid rules format. Expected a list or dict with 'rules' key")
+        logger.error(t("invalid_rules_format"))
         return
 
     if not rules:
-        logger.error("No valid rules found")
+        logger.error(t("no_valid_rules_found"))
         return
 
     # Parse file types
@@ -833,8 +1137,8 @@ def main():
     with open(output_file, "w", encoding="utf-8") as f:
         json.dump(results, f, indent=2, ensure_ascii=False)
 
-    logger.info(f"Results saved to: {output_file}")
-    logger.info(f"Total time elapsed: {time.perf_counter() - t0:.2f}s")
+    logger.info(t("results_saved_to", path=str(output_file)))
+    logger.info(t("total_time_elapsed", time=round(time.perf_counter() - t0, 2)))
 
 
 if __name__ == "__main__":