@heylemon/lemonade 0.0.4 → 0.0.6

package/skills/xlsx/scripts/office/validators/redlining.py

@@ -9,7 +9,6 @@ from pathlib import Path
 
 
 class RedliningValidator:
-    """Validator for tracked changes in Word documents."""
 
     def __init__(self, unpacked_dir, original_docx, verbose=False, author="Claude"):
         self.unpacked_dir = Path(unpacked_dir)
@@ -21,29 +20,23 @@ class RedliningValidator:
         }
 
     def repair(self) -> int:
-        """No auto-repairs for redlining validation. Returns 0."""
         return 0
 
     def validate(self):
-        """Main validation method that returns True if valid, False otherwise."""
-        # Verify unpacked directory exists and has correct structure
         modified_file = self.unpacked_dir / "word" / "document.xml"
         if not modified_file.exists():
             print(f"FAILED - Modified document.xml not found at {modified_file}")
             return False
 
-        # First, check if there are any tracked changes by the author to validate
         try:
             import xml.etree.ElementTree as ET
 
             tree = ET.parse(modified_file)
             root = tree.getroot()
 
-            # Check for w:del or w:ins tags by the specified author
             del_elements = root.findall(".//w:del", self.namespaces)
             ins_elements = root.findall(".//w:ins", self.namespaces)
 
-            # Filter to only include changes by the specified author
             author_del_elements = [
                 elem
                 for elem in del_elements
@@ -55,21 +48,17 @@ class RedliningValidator:
                 if elem.get(f"{{{self.namespaces['w']}}}author") == self.author
             ]
 
-            # Redlining validation is only needed if tracked changes by the author have been used.
             if not author_del_elements and not author_ins_elements:
                 if self.verbose:
                     print(f"PASSED - No tracked changes by {self.author} found.")
                 return True
 
         except Exception:
-            # If we can't parse the XML, continue with full validation
             pass
 
-        # Create temporary directory for unpacking original docx
         with tempfile.TemporaryDirectory() as temp_dir:
             temp_path = Path(temp_dir)
 
-            # Unpack original docx
             try:
                 with zipfile.ZipFile(self.original_docx, "r") as zip_ref:
                     zip_ref.extractall(temp_path)
@@ -84,7 +73,6 @@ class RedliningValidator:
                 )
                 return False
 
-            # Parse both XML files using xml.etree.ElementTree for redlining validation
             try:
                 import xml.etree.ElementTree as ET
 
@@ -96,16 +84,13 @@ class RedliningValidator:
                 print(f"FAILED - Error parsing XML files: {e}")
                 return False
 
-            # Remove the author's tracked changes from both documents
             self._remove_author_tracked_changes(original_root)
             self._remove_author_tracked_changes(modified_root)
 
-            # Extract and compare text content
             modified_text = self._extract_text_content(modified_root)
             original_text = self._extract_text_content(original_root)
 
             if modified_text != original_text:
-                # Show detailed character-level differences for each paragraph
                 error_message = self._generate_detailed_diff(
                     original_text, modified_text
                 )
@@ -117,7 +102,6 @@ class RedliningValidator:
             return True
 
     def _generate_detailed_diff(self, original_text, modified_text):
-        """Generate detailed word-level differences using git word diff."""
         error_parts = [
             f"FAILED - Document text doesn't match after removing {self.author}'s tracked changes",
             "",
@@ -132,7 +116,6 @@ class RedliningValidator:
             "",
         ]
 
-        # Show git word diff
         git_diff = self._get_git_word_diff(original_text, modified_text)
         if git_diff:
             error_parts.extend(["Differences:", "============", git_diff])
@@ -142,26 +125,23 @@ class RedliningValidator:
         return "\n".join(error_parts)
 
     def _get_git_word_diff(self, original_text, modified_text):
-        """Generate word diff using git with character-level precision."""
         try:
             with tempfile.TemporaryDirectory() as temp_dir:
                 temp_path = Path(temp_dir)
 
-                # Create two files
                 original_file = temp_path / "original.txt"
                 modified_file = temp_path / "modified.txt"
 
                 original_file.write_text(original_text, encoding="utf-8")
                 modified_file.write_text(modified_text, encoding="utf-8")
 
-                # Try character-level diff first for precise differences
                 result = subprocess.run(
                     [
                         "git",
                         "diff",
                         "--word-diff=plain",
-                        "--word-diff-regex=.",  # Character-by-character diff
-                        "-U0",  # Zero lines of context - show only changed lines
+                        "--word-diff-regex=.",  
+                        "-U0",  
                         "--no-index",
                         str(original_file),
                         str(modified_file),
@@ -171,9 +151,7 @@ class RedliningValidator:
                 )
 
                 if result.stdout.strip():
-                    # Clean up the output - remove git diff header lines
                     lines = result.stdout.split("\n")
-                    # Skip the header lines (diff --git, index, +++, ---, @@)
                     content_lines = []
                     in_content = False
                     for line in lines:
@@ -186,13 +164,12 @@ class RedliningValidator:
                     if content_lines:
                         return "\n".join(content_lines)
 
-                # Fallback to word-level diff if character-level is too verbose
                 result = subprocess.run(
                     [
                         "git",
                         "diff",
                         "--word-diff=plain",
-                        "-U0",  # Zero lines of context
+                        "-U0",  
                         "--no-index",
                         str(original_file),
                         str(modified_file),
@@ -214,18 +191,15 @@ class RedliningValidator:
                     return "\n".join(content_lines)
 
         except (subprocess.CalledProcessError, FileNotFoundError, Exception):
-            # Git not available or other error, return None to use fallback
             pass
 
         return None
 
     def _remove_author_tracked_changes(self, root):
-        """Remove tracked changes authored by the specified author from the XML root."""
         ins_tag = f"{{{self.namespaces['w']}}}ins"
         del_tag = f"{{{self.namespaces['w']}}}del"
         author_attr = f"{{{self.namespaces['w']}}}author"
 
-        # Remove w:ins elements
         for parent in root.iter():
             to_remove = []
             for child in parent:
@@ -234,7 +208,6 @@ class RedliningValidator:
             for elem in to_remove:
                 parent.remove(elem)
 
-        # Unwrap content in w:del elements where author matches
         deltext_tag = f"{{{self.namespaces['w']}}}delText"
         t_tag = f"{{{self.namespaces['w']}}}t"
 
@@ -244,36 +217,26 @@ class RedliningValidator:
                 if child.tag == del_tag and child.get(author_attr) == self.author:
                     to_process.append((child, list(parent).index(child)))
 
-            # Process in reverse order to maintain indices
             for del_elem, del_index in reversed(to_process):
-                # Convert w:delText to w:t before moving
                 for elem in del_elem.iter():
                     if elem.tag == deltext_tag:
                         elem.tag = t_tag
 
-                # Move all children of w:del to its parent before removing w:del
                 for child in reversed(list(del_elem)):
                     parent.insert(del_index, child)
                 parent.remove(del_elem)
 
     def _extract_text_content(self, root):
-        """Extract text content from Word XML, preserving paragraph structure.
-
-        Empty paragraphs are skipped to avoid false positives when tracked
-        insertions add only structural elements without text content.
-        """
         p_tag = f"{{{self.namespaces['w']}}}p"
         t_tag = f"{{{self.namespaces['w']}}}t"
 
         paragraphs = []
         for p_elem in root.findall(f".//{p_tag}"):
-            # Get all text elements within this paragraph
             text_parts = []
             for t_elem in p_elem.findall(f".//{t_tag}"):
                 if t_elem.text:
                     text_parts.append(t_elem.text)
             paragraph_text = "".join(text_parts)
-            # Skip empty paragraphs - they don't affect content validation
             if paragraph_text:
                 paragraphs.append(paragraph_text)
 

package/skills/xlsx/scripts/recalc.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 """
 Excel Formula Recalculation Script
 Recalculates all formulas in an Excel file using LibreOffice
@@ -15,12 +14,10 @@ from office.soffice import get_soffice_env
 
 from openpyxl import load_workbook
 
-# Platform-specific LibreOffice macro directory
 MACRO_DIR_MACOS = "~/Library/Application Support/LibreOffice/4/user/basic/Standard"
 MACRO_DIR_LINUX = "~/.config/libreoffice/4/user/basic/Standard"
 MACRO_FILENAME = "Module1.xba"
 
-# LibreOffice Basic macro for recalculation
 RECALCULATE_MACRO = """<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE script:module PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "module.dtd">
 <script:module xmlns:script="http://openoffice.org/2000/script" script:name="Module1" script:language="StarBasic">
@@ -33,7 +30,6 @@ RECALCULATE_MACRO = """<?xml version="1.0" encoding="UTF-8"?>
 
 
 def has_gtimeout():
-    """Check if gtimeout is available on macOS"""
     try:
         subprocess.run(
             ["gtimeout", "--version"], capture_output=True, timeout=1, check=False
@@ -44,20 +40,17 @@ def has_gtimeout():
 
 
 def setup_libreoffice_macro():
-    """Setup LibreOffice macro for recalculation if not already configured"""
     macro_dir = os.path.expanduser(
         MACRO_DIR_MACOS if platform.system() == "Darwin" else MACRO_DIR_LINUX
     )
     macro_file = os.path.join(macro_dir, MACRO_FILENAME)
 
-    # Check if macro already exists
     if (
         os.path.exists(macro_file)
         and "RecalculateAndSave" in Path(macro_file).read_text()
     ):
         return True
 
-    # Create macro directory if needed
     if not os.path.exists(macro_dir):
         subprocess.run(
             ["soffice", "--headless", "--terminate_after_init"],
@@ -67,7 +60,6 @@ def setup_libreoffice_macro():
         )
         os.makedirs(macro_dir, exist_ok=True)
 
-    # Write macro file
     try:
         Path(macro_file).write_text(RECALCULATE_MACRO)
         return True
@@ -76,16 +68,6 @@ def setup_libreoffice_macro():
 
 
 def recalc(filename, timeout=30):
-    """
-    Recalculate formulas in Excel file and report any errors
-
-    Args:
-        filename: Path to Excel file
-        timeout: Maximum time to wait for recalculation (seconds)
-
-    Returns:
-        dict with error locations and counts
-    """
     if not Path(filename).exists():
         return {"error": f"File {filename} does not exist"}
 
@@ -102,7 +84,6 @@ def recalc(filename, timeout=30):
         abs_path,
     ]
 
-    # Wrap command with timeout utility if available
     if platform.system() == "Linux":
         cmd = ["timeout", str(timeout)] + cmd
     elif platform.system() == "Darwin" and has_gtimeout():
@@ -110,13 +91,12 @@ def recalc(filename, timeout=30):
 
     result = subprocess.run(cmd, capture_output=True, text=True, env=get_soffice_env())
 
-    if result.returncode != 0 and result.returncode != 124:  # 124 is timeout exit code
+    if result.returncode != 0 and result.returncode != 124:  
         error_msg = result.stderr or "Unknown error during recalculation"
         if "Module1" in error_msg or "RecalculateAndSave" not in error_msg:
             return {"error": "LibreOffice macro not configured properly"}
         return {"error": error_msg}
 
-    # Check for Excel errors in the recalculated file - scan ALL cells
     try:
         wb = load_workbook(filename, data_only=True)
 
@@ -134,7 +114,6 @@ def recalc(filename, timeout=30):
 
         for sheet_name in wb.sheetnames:
             ws = wb[sheet_name]
-            # Check ALL rows and columns - no limits
             for row in ws.iter_rows():
                 for cell in row:
                     if cell.value is not None and isinstance(cell.value, str):
@@ -147,22 +126,19 @@ def recalc(filename, timeout=30):
 
         wb.close()
 
-        # Build result summary
         result = {
             "status": "success" if total_errors == 0 else "errors_found",
             "total_errors": total_errors,
             "error_summary": {},
         }
 
-        # Add non-empty error categories
         for err_type, locations in error_details.items():
             if locations:
                 result["error_summary"][err_type] = {
                     "count": len(locations),
-                    "locations": locations[:20],  # Show up to 20 locations
+                    "locations": locations[:20],  
                 }
 
-        # Add formula count for context - also check ALL cells
         wb_formulas = load_workbook(filename, data_only=False)
         formula_count = 0
         for sheet_name in wb_formulas.sheetnames:

package/skills/docx/scripts/__init__.py

@@ -1 +0,0 @@
-# Make scripts directory a package for relative imports in tests

package/skills/docx/scripts/office/validators/__init__.py

@@ -1,15 +0,0 @@
-"""
-Validation modules for Word document processing.
-"""
-
-from .base import BaseSchemaValidator
-from .docx import DOCXSchemaValidator
-from .pptx import PPTXSchemaValidator
-from .redlining import RedliningValidator
-
-__all__ = [
-    "BaseSchemaValidator",
-    "DOCXSchemaValidator",
-    "PPTXSchemaValidator",
-    "RedliningValidator",
-]

package/skills/pptx/scripts/office/validators/__init__.py

@@ -1,15 +0,0 @@
-"""
-Validation modules for Word document processing.
-"""
-
-from .base import BaseSchemaValidator
-from .docx import DOCXSchemaValidator
-from .pptx import PPTXSchemaValidator
-from .redlining import RedliningValidator
-
-__all__ = [
-    "BaseSchemaValidator",
-    "DOCXSchemaValidator",
-    "PPTXSchemaValidator",
-    "RedliningValidator",
-]

package/skills/xlsx/scripts/office/validators/__init__.py

@@ -1,15 +0,0 @@
-"""
-Validation modules for Word document processing.
-"""
-
-from .base import BaseSchemaValidator
-from .docx import DOCXSchemaValidator
-from .pptx import PPTXSchemaValidator
-from .redlining import RedliningValidator
-
-__all__ = [
-    "BaseSchemaValidator",
-    "DOCXSchemaValidator",
-    "PPTXSchemaValidator",
-    "RedliningValidator",
-]