pysfi 0.1.11__tar.gz → 0.1.12__tar.gz

{pysfi-0.1.11 → pysfi-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysfi
-Version: 0.1.11
+Version: 0.1.12
 Summary: Single File commands for Interactive python.
 Requires-Python: >=3.8
 Requires-Dist: tomli>=2.4.0; python_version < '3.11'
@@ -17,6 +17,7 @@ Requires-Dist: pyside2>=5.15.2.1; extra == 'all'
 Requires-Dist: pytesseract>=0.3.10; extra == 'all'
 Requires-Dist: python-docx>=1.1.0; extra == 'all'
 Requires-Dist: python-pptx>=0.6.21; extra == 'all'
+Requires-Dist: pywin32>=311; (sys_platform == 'win32') and extra == 'all'
 Provides-Extra: extra
 Requires-Dist: ebooklib>=0.18; extra == 'extra'
 Requires-Dist: markdown>=3.5; extra == 'extra'
@@ -33,6 +34,7 @@ Requires-Dist: openpyxl>=3.1.0; extra == 'office'
 Requires-Dist: pymupdf>=1.24.11; extra == 'office'
 Requires-Dist: python-docx>=1.1.0; extra == 'office'
 Requires-Dist: python-pptx>=0.6.21; extra == 'office'
+Requires-Dist: pywin32>=311; (sys_platform == 'win32') and extra == 'office'
 Description-Content-Type: text/markdown
 
 # pysfi

{pysfi-0.1.11 → pysfi-0.1.12}/pyproject.toml

@@ -8,13 +8,14 @@ description = "Single File commands for Interactive python."
 name = "pysfi"
 readme = "README.md"
 requires-python = ">=3.8"
-version = "0.1.11"
+version = "0.1.12"
 
 [project.scripts]
 alarmclk = "sfi.alarmclock.alarmclock:main"
 bumpversion = "sfi.bumpversion.bumpversion:main"
 cleanbuild = "sfi.cleanbuild.cleanbuild:main"
 condasetup = "sfi.condasetup.condasetup:main"
+docdiff = "sfi.docdiff.docdiff:main"
 docscan = "sfi.docscan.docscan:main"
 docscan-gui = "sfi.docscan.docscan_gui:main"
 filedate = "sfi.filedate.filedate:main"
@@ -49,6 +50,7 @@ office = [
     "pymupdf>=1.24.11",
     "python-docx>=1.1.0",
     "python-pptx>=0.6.21",
+    "pywin32>=311; sys.platform=='win32'",
 ]
 
 [tool.hatch.build.targets.wheel]
@@ -129,6 +131,7 @@ members = [
     "sfi/bumpversion",
     "sfi/cleanbuild",
     "sfi/condasetup",
+    "sfi/docdiff",
     "sfi/docscan",
     "sfi/filedate",
     "sfi/gittool",

{pysfi-0.1.11 → pysfi-0.1.12}/sfi/__init__.py

@@ -1,3 +1,3 @@
 """Single File commands for Interactive python."""
 
-__version__ = "0.1.11"
+__version__ = "0.1.12"

{pysfi-0.1.11 → pysfi-0.1.12}/sfi/bumpversion/__init__.py

@@ -1,3 +1,3 @@
 """Bumpversion - Automated version number management tool."""
 
-__version__ = "0.1.11"
+__version__ = "0.1.12"

pysfi-0.1.12/sfi/docdiff/README.md

@@ -0,0 +1,108 @@
+# DocDiff - Word Document Comparison Tool
+
+DocDiff is a Python tool that compares two Microsoft Word documents (.doc/.docx) and generates a comparison report highlighting the differences between them.
+
+## Features
+
+- Compares two Word documents and highlights differences
+- Supports both .doc and .docx file formats
+- Configurable comparison options
+- Automatic configuration persistence
+- Command-line interface for easy automation
+
+## Installation
+
+This module is part of the pysfi package. Make sure you have the required dependencies:
+
+```bash
+pip install pywin32
+```
+
+Note: This tool only works on Windows systems with Microsoft Word installed.
+
+## Usage
+
+### Command Line Interface
+
+```bash
+# Basic usage
+python -m sfi.docdiff old_document.docx new_document.docx
+
+# Specify output directory
+python -m sfi.docdiff old_document.docx new_document.docx --output-dir ./results
+
+# Customize the comparison title
+python -m sfi.docdiff old_document.docx new_document.docx --title "My Comparison Report"
+
+# Control change visibility
+python -m sfi.docdiff old_document.docx new_document.docx --show-changes
+python -m sfi.docdiff old_document.docx new_document.docx --hide-changes
+
+# Specify comparison mode
+python -m sfi.docdiff old_document.docx new_document.docx --compare-mode original
+python -m sfi.docdiff old_document.docx new_document.docx --compare-mode revised
+
+# Specify custom output path
+python -m sfi.docdiff old_document.docx new_document.docx -o ./output/comparison_result.docx
+```
+
+### Configuration
+
+The tool automatically saves and loads configuration from `~/.sfi/docdiff.json`. The configuration includes:
+
+- `DOC_DIFF_TITLE`: Title for the comparison result
+- `OUTPUT_DIR`: Directory for output files
+- `COMPARE_MODE`: Comparison mode (original/revised)
+- `SHOW_CHANGES`: Whether to show changes in the comparison
+- `TRACK_REVISIONS`: Whether to track revisions
+
+## Programmatic Usage
+
+```python
+from sfi.docdiff.docdiff import diff_doc
+from pathlib import Path
+
+# Compare two documents
+old_file = Path("old_document.docx")
+new_file = Path("new_document.docx")
+diff_doc(old_file, new_file)
+```
+
+## Configuration API
+
+```python
+from sfi.docdiff.docdiff import DocDiffConfig
+
+# Access current configuration
+config = DocDiffConfig()
+print(config.DOC_DIFF_TITLE)
+
+# Modify configuration (will be saved on program exit)
+config.DOC_DIFF_TITLE = "New Title"
+config.SHOW_CHANGES = False
+```
+
+## Requirements
+
+- Windows operating system
+- Microsoft Word installed
+- Python 3.8+
+- pywin32 package
+
+## Testing
+
+Run the unit tests:
+
+```bash
+python -m pytest sfi/docdiff/tests/test_docdiff.py
+```
+
+Run the benchmark tests:
+
+```bash
+python -m pytest sfi/docdiff/tests/test_benchmark.py
+```
+
+## License
+
+This project is part of pysfi and is licensed under the terms specified in the main project repository.

pysfi-0.1.12/sfi/docdiff/docdiff.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import argparse
+import atexit
+import json
+import logging
+import platform
+import subprocess
+import time
+from dataclasses import dataclass
+from functools import cached_property
+from pathlib import Path
+from typing import Any
+
+CONFIG_FILE = Path.home() / ".sfi" / "docdiff.json"
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DocDiffConfig:
+    """Document comparison configuration."""
+
+    DOC_DIFF_TITLE: str = "Comparison Result"
+    OUTPUT_DIR: str = str(Path.home())  # Use current directory if empty
+    COMPARE_MODE: str = "original"  # Options: original, revised
+    SHOW_CHANGES: bool = True
+    TRACK_REVISIONS: bool = True
+
+    def __init__(self) -> None:
+        if CONFIG_FILE.exists():
+            logger.info("Loading configuration from %s", CONFIG_FILE)
+            config_data = json.loads(CONFIG_FILE.read_text())
+            # Update configuration items, keeping defaults as fallback
+            for key, value in config_data.items():
+                if hasattr(self, key):
+                    setattr(self, key, value)
+        else:
+            logger.info("Using default configuration")
+
+    def save(self) -> None:
+        """Save configuration."""
+        CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        CONFIG_FILE.write_text(json.dumps(vars(self), indent=4))
+
+
+conf = DocDiffConfig()
+atexit.register(conf.save)
+
+
+@dataclass(frozen=True)
+class DiffDocCommand:
+    """Document comparison command."""
+
+    old_doc: Path
+    new_doc: Path
+    output_path: Path | None = None
+
+    def run(self) -> None:
+        """Run the document comparison command."""
+        if platform.system() != "Windows":
+            logger.error("This tool is only available on Windows.")
+            return
+        if not self.old_doc.exists():
+            logger.error(f"Old file does not exist: {self.old_doc}")
+            return
+
+        if not self.new_doc.exists():
+            logger.error(f"New file does not exist: {self.new_doc}")
+            return
+
+        if not self.validate_files:
+            logger.error("Invalid file paths or extensions")
+            return
+
+        if self.word_app is None:
+            logger.error("Word application is not available")
+            return
+
+        if self.compare_data is None:
+            return
+
+        self.output.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            self.compare_data.SaveAs2(str(self.output))
+            self.compare_data.Close()
+        except Exception as e:
+            logger.exception(f"Comparison failed: {e}")
+        else:
+            logger.info(f"Comparison completed. Saved to: {self.output}")
+        finally:
+            try:
+                self.word_app.Documents.Close(SaveChanges=False)
+            except Exception:
+                logger.exception("Close document failed!")
+            else:
+                self.word_app.Quit()
+
+            try:
+                subprocess.run(
+                    ["taskkill", "/f", "/t", "/im", "WINWORD.EXE"], check=False
+                )
+            except Exception:
+                logger.exception("Taskkill failed!")
+            else:
+                logger.info("Taskkill completed successfully")
+
+    @cached_property
+    def word_app(self) -> Any:
+        try:
+            import win32com.client as win32  # type: ignore
+        except ImportError:
+            logger.exception("win32com.client is not installed, exiting.")
+            raise
+        else:
+            logger.info("Started Word application")
+            app = win32.gencache.EnsureDispatch("Word.Application")  # type: ignore
+            app.Visible = False
+            app.DisplayAlerts = False
+
+            try:
+                app.Options.TrackRevisions = conf.TRACK_REVISIONS
+            except AttributeError:
+                logger.warning(
+                    "TrackRevisions option not available in this Word version"
+                )
+
+            return app
+
+    @cached_property
+    def validate_files(self) -> bool:
+        return all([
+            self.old_doc.exists(),
+            self.new_doc.exists(),
+            self.old_doc.suffix.lower() in [".doc", ".docx"],
+            self.new_doc.suffix.lower() in [".doc", ".docx"],
+        ])
+
+    @cached_property
+    def compare_data(self) -> Any:
+        try:
+            compared = self.word_app.CompareDocuments(
+                self.old_doc_data,
+                self.new_doc_data,
+                0,
+                2 if conf.COMPARE_MODE == "revised" else 0,
+                True,
+            )
+        except Exception as e:
+            logger.exception(f"Comparison failed: {e}")
+            return None
+        else:
+            if compared:
+                logger.info("Comparison completed successfully")
+                compared.ShowRevisions = conf.SHOW_CHANGES
+                return compared
+            return None
+
+    @cached_property
+    def old_doc_data(self) -> Any:
+        logger.info(f"Opening old file: {self.old_doc}")
+        return self.word_app.Documents.Open(str(self.old_doc.resolve()))
+
+    @cached_property
+    def new_doc_data(self) -> Any:
+        logger.info(f"Opening new file: {self.new_doc}")
+        return self.word_app.Documents.Open(str(self.new_doc.resolve()))
+
+    @cached_property
+    def output(self) -> Path:
+        """Determine the output directory for the comparison result."""
+        output_filename = (
+            f"{conf.DOC_DIFF_TITLE}@{time.strftime('%Y%m%d_%H_%M_%S')}.docx"
+        )
+
+        if self.output_path is None:
+            output_dir = (
+                Path(conf.OUTPUT_DIR) if conf.OUTPUT_DIR else self.new_doc.parent
+            )
+            return output_dir / output_filename
+
+        if self.output_path.is_dir():
+            return self.output_path / output_filename
+        elif self.output_path.is_file():
+            return self.output_path
+        else:
+            raise ValueError(f"Invalid output path: {self.output_path}")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Compare two doc/docx files.")
+    parser.add_argument(
+        "files", nargs=2, help="Two input files to compare (old_file new_file)"
+    )
+    parser.add_argument(
+        "-o", "--output", dest="output", default=".", help="Output file path"
+    )
+    parser.add_argument("--title", help="Title for the comparison result")
+    parser.add_argument(
+        "--show-changes", action="store_true", help="Show changes in the comparison"
+    )
+    parser.add_argument(
+        "--hide-changes", action="store_true", help="Hide changes in the comparison"
+    )
+    parser.add_argument(
+        "--compare-mode",
+        choices=["original", "revised"],
+        help="Compare mode: original or revised",
+    )
+    parser.add_argument("--output-dir", help="Output directory for the result file")
+
+    args = parser.parse_args()
+
+    # Update configuration from command line arguments
+    if args.title:
+        conf.DOC_DIFF_TITLE = args.title
+    if args.show_changes:
+        conf.SHOW_CHANGES = True
+    if args.hide_changes:
+        conf.SHOW_CHANGES = False
+    if args.compare_mode:
+        conf.COMPARE_MODE = args.compare_mode
+    if args.output_dir:
+        conf.OUTPUT_DIR = args.output_dir
+
+    return args
+
+
+def main() -> None:
+    """Compare two doc/docx files."""
+    args = parse_args()
+
+    DiffDocCommand(
+        Path(args.files[0]),
+        Path(args.files[1]),
+        Path(args.output),
+    ).run()

pysfi-0.1.12/sfi/docdiff/tests/test_benchmark.py

@@ -0,0 +1,98 @@
+"""
+Benchmark tests for docdiff module.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from sfi.docdiff.docdiff import DiffDocCommand, DocDiffConfig
+
+
+class TestDocDiffBenchmark:
+    """Benchmark tests for docdiff functionality."""
+
+    @pytest.mark.benchmark(group="config_operations")
+    def test_config_creation_benchmark(self, benchmark):
+        """Benchmark configuration creation."""
+        result = benchmark(DocDiffConfig)
+        assert result is not None
+
+    @pytest.mark.benchmark(group="config_operations")
+    def test_config_save_benchmark(self, benchmark, tmp_path):
+        """Benchmark configuration save operation."""
+        # Create a temporary config file
+        temp_config_file = tmp_path / "benchmark_config.json"
+
+        # Patch the global CONFIG_FILE
+        with patch("sfi.docdiff.docdiff.CONFIG_FILE", temp_config_file):
+            config = DocDiffConfig()
+
+            result = benchmark(config.save)
+            assert result is None
+
+
+def test_command_creation_benchmark(benchmark, tmp_path):
+    """Benchmark DiffDocCommand creation."""
+    old_file = tmp_path / "old.docx"
+    new_file = tmp_path / "new.docx"
+    output_path = tmp_path / "output"
+
+    old_file.touch()
+    new_file.touch()
+
+    def create_command():
+        return DiffDocCommand(old_file, new_file, output_path)
+
+    result = benchmark(create_command)
+    assert result is not None
+
+
+def test_full_workflow_benchmark(benchmark, tmp_path):
+    """Benchmark the full workflow including config and command."""
+
+    def full_workflow():
+        # Create config
+        config = DocDiffConfig()
+
+        # Create dummy files
+        old_file = tmp_path / "old_bench.docx"
+        new_file = tmp_path / "new_bench.docx"
+
+        old_file.touch()
+        new_file.touch()
+
+        # Create command
+        command = DiffDocCommand(old_file, new_file)
+
+        # Mock the win32com import and Word operations
+        with patch.dict(
+            "sys.modules", {"win32com": MagicMock(), "win32com.client": MagicMock()}
+        ):
+            import win32com.client as win32
+
+            with patch.object(win32.gencache, "EnsureDispatch") as mock_dispatch:
+                mock_word_app = MagicMock()
+                mock_dispatch.return_value = mock_word_app
+
+                mock_doc_old = MagicMock()
+                mock_doc_new = MagicMock()
+                mock_doc_compare = MagicMock()
+
+                # Configure the mocked documents
+                mock_word_app.Documents.Open.side_effect = [mock_doc_old, mock_doc_new]
+                mock_word_app.CompareDocuments.return_value = mock_doc_compare
+
+                # We can't call run() directly because of the complex property dependencies
+                # So we'll just test property access
+                try:
+                    _ = command.validate_files
+                except:
+                    pass
+
+    benchmark(full_workflow)
+
+
+if __name__ == "__main__":
+    # Run benchmark tests
+    pytest.main([__file__, "-v", "--benchmark-only", "--benchmark-sort=fullname"])

pysfi-0.1.12/sfi/docdiff/tests/test_docdiff.py

@@ -0,0 +1,188 @@
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from sfi.docdiff.docdiff import DiffDocCommand, DocDiffConfig
+
+
+class TestDocDiffConfig:
+    """Test DocDiffConfig functionality."""
+
+    def test_config_initialization_with_defaults(self):
+        """Test that config initializes with default values."""
+        config = DocDiffConfig()
+
+        assert config.DOC_DIFF_TITLE == "Comparison Result"
+        assert str(Path.home()) == config.OUTPUT_DIR
+        assert config.COMPARE_MODE == "original"
+        assert config.SHOW_CHANGES is True
+        assert config.TRACK_REVISIONS is True
+
+    def test_config_save_and_load(self, tmp_path):
+        """Test saving and loading config."""
+        # Create a temporary config file
+        temp_config_file = tmp_path / "docdiff_test.json"
+
+        # Patch the global CONFIG_FILE
+        with patch("sfi.docdiff.docdiff.CONFIG_FILE", temp_config_file):
+            # Create config and modify values
+            config = DocDiffConfig()
+            config.DOC_DIFF_TITLE = "Test Title"
+            config.OUTPUT_DIR = str(tmp_path / "output")
+
+            # Save config
+            config.save()
+
+            # Verify file was created
+            assert temp_config_file.exists()
+
+            # Create new config instance (should load from file)
+            new_config = DocDiffConfig()
+            assert new_config.DOC_DIFF_TITLE == "Test Title"
+            assert str(tmp_path / "output") == new_config.OUTPUT_DIR
+
+
+class TestDiffDocCommand:
+    """Test DiffDocCommand functionality."""
+
+    def test_command_initialization(self, tmp_path):
+        """Test DiffDocCommand initialization."""
+        old_file = tmp_path / "old.docx"
+        new_file = tmp_path / "new.docx"
+        output_path = tmp_path / "output"
+
+        command = DiffDocCommand(old_file, new_file, output_path)
+
+        assert command.old_doc == old_file
+        assert command.new_doc == new_file
+        assert command.output_path == output_path
+
+    def test_command_with_nonexistent_files(self, tmp_path, caplog):
+        """Test DiffDocCommand with nonexistent files."""
+        old_file = tmp_path / "nonexistent_old.docx"
+        new_file = tmp_path / "nonexistent_new.docx"
+
+        command = DiffDocCommand(old_file, new_file)
+        command.run()
+
+        # Check that error messages were logged
+        assert "Old file does not exist" in caplog.text
+
+    def test_validate_files_property(self, tmp_path):
+        """Test the validate_files property."""
+        old_file = tmp_path / "old.docx"
+        new_file = tmp_path / "new.docx"
+
+        # Create the files
+        old_file.touch()
+        new_file.touch()
+
+        command = DiffDocCommand(old_file, new_file)
+
+        # Since validate_files is a cached property, we can't easily patch it.
+        # Instead, we'll test the underlying logic by checking file extensions
+        assert old_file.suffix.lower() in [".doc", ".docx"]
+        assert new_file.suffix.lower() in [".doc", ".docx"]
+        assert old_file.exists()
+        assert new_file.exists()
+
+        # Test with invalid extension
+        bad_file = tmp_path / "bad.txt"
+        bad_file.touch()
+
+        # Create a new command with the bad file
+        bad_command = DiffDocCommand(bad_file, new_file)
+        # We can't easily test the property directly due to frozen dataclass,
+        # but we can test the logic
+        assert bad_file.suffix.lower() not in [".doc", ".docx"]
+
+    def test_command_missing_win32com(self, tmp_path, caplog):
+        """Test DiffDocCommand when win32com is not available."""
+        old_file = tmp_path / "old.docx"
+        new_file = tmp_path / "new.docx"
+
+        # Create the files
+        old_file.touch()
+        new_file.touch()
+
+        # Mock platform and file validation to bypass early checks
+        with patch(
+            "sfi.docdiff.docdiff.platform.system", return_value="Windows"
+        ), patch.object(Path, "exists", return_value=True):
+            command = DiffDocCommand(old_file, new_file)
+
+            # Temporarily remove win32com from sys.modules if present
+            original_win32com = sys.modules.get("win32com")
+            if "win32com" in sys.modules:
+                del sys.modules["win32com"]
+
+            try:
+                # Try to access the word_app property which will trigger win32com import
+                with patch.dict("sys.modules", {"win32com.client": None}):
+                    try:
+                        _ = command.word_app  # This should trigger the exception
+                    except ImportError:
+                        pass  # Expected
+                    except Exception:
+                        pass  # Other exceptions are OK too
+            finally:
+                # Restore original module if it existed
+                if original_win32com is not None:
+                    sys.modules["win32com"] = original_win32com
+
+    def test_word_app_property_success(self, tmp_path):
+        """Test word_app property when win32com is available."""
+        old_file = tmp_path / "old.docx"
+        new_file = tmp_path / "new.docx"
+
+        # Create the files
+        old_file.touch()
+        new_file.touch()
+
+        # Mock platform to bypass early checks
+        with patch(
+            "sfi.docdiff.docdiff.platform.system", return_value="Windows"
+        ), patch.object(Path, "exists", return_value=True):
+            command = DiffDocCommand(old_file, new_file)
+
+            # Mock win32com
+            mock_win32 = MagicMock()
+            mock_app = MagicMock()
+            mock_win32.gencache.EnsureDispatch.return_value = mock_app
+
+            with patch.dict("sys.modules", {"win32com.client": mock_win32}):
+                # Access the property
+                app = command.word_app
+
+                # Verify the dispatch was called correctly
+                mock_win32.gencache.EnsureDispatch.assert_called_once_with(
+                    "Word.Application"
+                )
+                assert app == mock_app
+                assert mock_app.Visible is False
+                assert mock_app.DisplayAlerts is False
+
+
+class TestIntegration:
+    """Integration tests for docdiff functionality."""
+
+    def test_command_creation(self, tmp_path):
+        """Test creating and using DiffDocCommand."""
+        old_file = tmp_path / "old.docx"
+        new_file = tmp_path / "new.docx"
+        output_file = tmp_path / "output.docx"
+
+        old_file.touch()
+        new_file.touch()
+
+        command = DiffDocCommand(old_file, new_file, output_file)
+
+        assert command.old_doc == old_file
+        assert command.new_doc == new_file
+        assert command.output_path == output_file
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])