pdflinkcheck 1.1.72__py3-none-any.whl → 1.1.94__py3-none-any.whl

pdflinkcheck/report.py

@@ -1,3 +1,5 @@
+#!/usr/bin/env python3 
+# SPDX-License-Identifier: MIT
 # pdflinkcheck/report.py
 
 import sys
@@ -6,9 +8,30 @@ from typing import Optional, Dict, Any
 import pyhabitat
 
 from pdflinkcheck.io import error_logger, export_report_json, export_report_txt, get_first_pdf_in_cwd, get_friendly_path, LOG_FILE_PATH
+from pdflinkcheck.environment import pymupdf_is_available
+from pdflinkcheck.validate import run_validation
 
+SEP_COUNT=28
+            
+def run_report_and_call_exports(pdf_path: str = None,  max_links: int = 0, export_format: str = "JSON", pdf_library: str = "pypdf", print_bool:bool=True) -> Dict[str, Any]:
+    # The meat and potatoes
+    report_results = run_report_and_validtion(
+        pdf_path=str(pdf_path), 
+        max_links=max_links,
+        pdf_library = pdf_library,
+    )
+    if export_format:
+        report_data_dict = report_results["data"]
+        report_buffer_str = report_results["text"]
+        if "JSON" in export_format.upper():
+            export_report_json(report_data_dict, pdf_path, pdf_library)
+        
+        if "TXT" in export_format.upper():
+            export_report_txt(report_buffer_str, pdf_path, pdf_library)
+    return report_results
+    
 
-def run_report(pdf_path: str = None,  max_links: int = 0, export_format: str = "JSON", pdf_library: str = "pypdf", print_bool:bool=True) -> Dict[str, Any]:
+def run_report_and_validtion(pdf_path: str = None,  max_links: int = 0, pdf_library: str = "pypdf", print_bool:bool=True) -> Dict[str, Any]:
     """
     Core high-level PDF link analysis logic. 
     
@@ -34,8 +57,8 @@ def run_report(pdf_path: str = None,  max_links: int = 0, export_format: str = "
 
     # Helper to handle conditional printing and mandatory buffering
     def log(msg: str):
-        if print_bool: # this should not be here
-            print(msg) # this should not be here. esure elsewhere then remove
+        if print_bool:
+            print(msg)
         report_buffer.append(msg)
 
     # Expected: "pypdf" or "PyMuPDF"
@@ -44,26 +67,38 @@ def run_report(pdf_path: str = None,  max_links: int = 0, export_format: str = "
     if pdf_library in allowed_libraries and pdf_library == "pypdf":
         from pdflinkcheck.analyze_pypdf import (extract_links_pypdf as extract_links, extract_toc_pypdf as extract_toc)
     elif pdf_library in allowed_libraries and pdf_library == "pymupdf":
-        try:
-            import fitz
-        except ImportError:
+        if not pymupdf_is_available():
             print("PyMuPDF was explicitly requested as the PDF Engine")
-            print("Use pypdf instead, or install PyMuPDF. ")
+            print("Switch the PDF library to 'pypdf' instead, or install PyMuPDF. ")
             print("To install PyMuPDF locally, try: `uv sync --extra full` OR `pip install .[full]`")
             if pyhabitat.on_termux():
                 print(f"pyhabitat.on_termux() = {pyhabitat.on_termux()}")
                 print("PyMuPDF is not expected to work on Termux. Use pypdf.")
             print("\n")
-            return    
+            #return    
+            raise ImportError(f"The 'fitz' module is required for this functionality. Original error: {e}") from e
         from pdflinkcheck.analyze_pymupdf import (extract_links_pymupdf as extract_links, extract_toc_pymupdf as extract_toc)
     
     log("\n--- Starting Analysis ... ---\n")
-    if pdf_path is None:
-        pdf_path = get_first_pdf_in_cwd()
     if pdf_path is None:
         log("pdf_path is None")
         log("Tip: Drop a PDF in the current folder or pass in a path arg.")
-        return
+        empty_report = {
+                "data": {
+                    "external_links": [],
+                    "internal_links": [],
+                    "toc": []
+                },
+                "text": "\n".join(report_buffer),
+                "metadata": {
+                    "pdf_name": Path(pdf_path).name,
+                    "library_used": pdf_library,
+                    "total_links": 0
+                }
+            }
+
+        return empty_report
+        
     try:
         log(f"Target file: {get_friendly_path(pdf_path)}")
         log(f"PDF Engine: {pdf_library}")
@@ -78,7 +113,21 @@ def run_report(pdf_path: str = None,  max_links: int = 0, export_format: str = "
         if not extracted_links and not structural_toc:
             log(f"\nNo hyperlinks or structural TOC found in {Path(pdf_path).name}.")
             log("(This is common for scanned/image-only PDFs.)")
-            return {}
+
+            empty_result = {
+                "data": {
+                    "external_links": [],
+                    "internal_links": [],
+                    "toc": []
+                },
+                "text": "\n".join(report_buffer),
+                "metadata": {
+                    "pdf_name": Path(pdf_path).name,
+                    "library_used": pdf_library,
+                    "total_links": 0
+                }
+            }
+            return empty_result
             
         # 3. Separate the lists based on the 'type' key
         uri_links = [link for link in extracted_links if link['type'] == 'External (URI)']
@@ -89,24 +138,25 @@ def run_report(pdf_path: str = None,  max_links: int = 0, export_format: str = "
         total_internal_links = len(goto_links) + len(resolved_action_links)
         limit = max_links if max_links > 0 else None
         uri_and_other = uri_links + other_links
+
+        str_structural_toc = get_structural_toc(structural_toc)
         
         # --- ANALYSIS SUMMARY (Using your print logic) ---
-        log("\n" + "=" * 70)
+        log("\n" + "=" * SEP_COUNT)
         log(f"--- Link Analysis Results for {Path(pdf_path).name} ---")
         log(f"Total active links: {len(extracted_links)} (External: {len(uri_links)}, Internal Jumps: {total_internal_links}, Other: {len(other_links)})")
         log(f"Total **structural TOC entries (bookmarks)** found: {toc_entry_count}")
-        log("=" * 70)
+        log("=" * SEP_COUNT)
 
         # --- Section 1: TOC ---
-        str_structural_toc = print_structural_toc(structural_toc)
         log(str_structural_toc)
 
         # --- Section 2: ACTIVE INTERNAL JUMPS ---
-        log("\n" + "=" * 70)
+        log("\n" + "=" * SEP_COUNT)
         log(f"## Active Internal Jumps (GoTo & Resolved Actions) - {total_internal_links} found")
-        log("=" * 70)
+        log("=" * SEP_COUNT)
         log("{:<5} | {:<5} | {:<40} | {}".format("Idx", "Page", "Anchor Text", "Jumps To Page"))
-        log("-" * 70)
+        log("-" * SEP_COUNT)
         
         all_internal = goto_links + resolved_action_links
         if total_internal_links > 0:
@@ -118,13 +168,13 @@ def run_report(pdf_path: str = None,  max_links: int = 0, export_format: str = "
                 log(f"... and {len(all_internal) - limit} more links (use --max-links 0 to show all).")
         else:
             log(" No internal GoTo or Resolved Action links found.")
-        log("-" * 70)
+        log("-" * SEP_COUNT)
         
         # --- Section 3: ACTIVE URI LINKS ---
-        log("\n" + "=" * 70)
+        log("\n" + "=" * SEP_COUNT)
         log(f"## Active URI Links (External & Other) - {len(uri_and_other)} found") 
         log("{:<5} | {:<5} | {:<40} | {}".format("Idx", "Page", "Anchor Text", "Target URI/Action"))
-        log("=" * 70)
+        log("=" * SEP_COUNT)
         
         if uri_and_other:
             for i, link in enumerate(uri_and_other[:limit], 1):
@@ -136,45 +186,53 @@ def run_report(pdf_path: str = None,  max_links: int = 0, export_format: str = "
 
         else: 
             log(" No external or 'Other' links found.")
-        log("-" * 70)
-
-        log("\n--- Analysis Complete ---\n")
+        log("-" * SEP_COUNT)
 
-        # Final aggregation of the buffer into one string
-        report_buffer_str = "\n".join(report_buffer)
         
         # Return the collected data for potential future JSON/other output
-        final_report_data_dict =  {
+        report_data_dict =  {
             "external_links": uri_links,
             "internal_links": all_internal,
-            "toc": structural_toc
+            "toc": structural_toc,
+            "validation": {}
         }
 
-        # 5. Export Report 
-        #if export_format:
-        #    # Assuming export_to will hold the output format string (e.g., "JSON")
-        #    export_report_data(final_report_data_dict, Path(pdf_path).name, export_format, pdf_library)
-        
-        if export_format:
-            fmt_upper = export_format.upper()
-            
-            if "JSON" in fmt_upper:
-                export_report_json(final_report_data_dict, pdf_path, pdf_library)
-            
-            if "TXT" in fmt_upper:
-                export_report_txt(report_buffer_str, pdf_path, pdf_library)
-        
-        report_results = {
-            "data": final_report_data_dict, # The structured JSON-ready dict
-            "text": report_buffer_str,      # The human-readable string
+        intermediate_report_results = {
+            "data": report_data_dict, # The structured JSON-ready dict
+            "text": "",
             "metadata": {                  # Helpful for the GUI/Logs
                 "pdf_name": Path(pdf_path).name,
                 "library_used": pdf_library,
                 "total_links": len(extracted_links)
             }
         }
+
+        log("\n--- Analysis Complete ---")
+
+        validation_results = run_validation(report_results=intermediate_report_results,
+                                            pdf_path=pdf_path,
+                                            pdf_library=pdf_library)
+        log(validation_results.get("summary-txt",""))
+        report_results = intermediate_report_results
+
+        # Final aggregation of the buffer into one string, after the last call to log()
+        report_buffer_str = "\n".join(report_buffer)
+
+        report_results["data"]["validation"].update(validation_results)
+        #report_results["text"].update(report_buffer_str)      # The human-readable string
+        report_results["text"] = report_buffer_str
+
+        # 5. Export Report 
+        #if export_format:
+        #    # Assuming export_to will hold the output format string (e.g., "JSON")
+        #    export_report_data(report_data_dict, Path(pdf_path).name, export_format, pdf_library)
+        
+        if print_bool:
+            print(report_buffer_str)
+            
         # Return a clean results object
         return report_results
+    
     except Exception as e:
         # Specific handling for common read failures
         if "invalid pdf header" in str(e).lower() or "EOF marker not found" in str(e) or "stream has ended unexpectedly" in str(e):
@@ -194,44 +252,36 @@ def run_report(pdf_path: str = None,  max_links: int = 0, export_format: str = "
                 }
             }
 
+    #except Exception as e:
+    #    # Log the critical failure
+    #    error_logger.error(f"Critical failure during run_report for {pdf_path}: {e}", exc_info=True)
+    #    log(f"FATAL: Analysis failed. Check logs at {LOG_FILE_PATH}", file=sys.stderr)
+    #    raise # Allow the exception to propagate or handle gracefully
     except Exception as e:
-        # Log the critical failure
         error_logger.error(f"Critical failure during run_report for {pdf_path}: {e}", exc_info=True)
-        log(f"FATAL: Analysis failed. Check logs at {LOG_FILE_PATH}", file=sys.stderr)
-        raise # Allow the exception to propagate or handle gracefully
-
-
-def print_structural_toc_print(structural_toc:dict)->str|None:
-    """
-    Prints the structural TOC data (bookmarks/outline) in a clean, 
-    hierarchical, and readable console format.
-
-    Args:
-        structural_toc: A list of TOC dictionaries.
-    """
-    print("\n" + "=" * 70)
-    print("## Structural Table of Contents (PDF Bookmarks/Outline)")
-    print("=" * 70)
-    if not structural_toc:
-        print("No structural TOC (bookmarks/outline) found.")
-        return
-
-    # Determine max page width for consistent alignment (optional but nice)
-    max_page = max(item['target_page'] for item in structural_toc) if structural_toc else 1
-    page_width = len(str(max_page))
-    
-    # Iterate and format
-    for item in structural_toc:
-        # Use level for indentation (e.g., Level 1 = 0 spaces, Level 2 = 4 spaces, Level 3 = 8 spaces)
-        indent = " " * 4 * (item['level'] - 1)
-        # Format the title and target page number
-        page_str = str(item['target_page']).rjust(page_width)
-        print(f"{indent}{item['title']} . . . page {page_str}")
-
-    print("-" * 70)
-
-
-def print_structural_toc(structural_toc: list, print_bool: bool = False) -> str:
+        log(f"FATAL: Analysis failed: {str(e)}. Check logs at {LOG_FILE_PATH}", file=sys.stderr)
+
+        # Always return a safe empty result on error
+        return {
+            "data": {
+                "external_links": [],
+                "internal_links": [],
+                "toc": [],
+                "validation": {}
+            },
+            "text": "\n".join(report_buffer + [
+                "\n--- Analysis failed ---",
+                f"Error: {str(e)}",
+                "No links or TOC extracted."
+            ]),
+            "metadata": {
+                "pdf_name": Path(pdf_path).name,
+                "library_used": pdf_library,
+                "total_links": 0
+            }
+        }
+        
+def get_structural_toc(structural_toc: list) -> str:
     """
     Formats the structural TOC data into a hierarchical string and optionally prints it.
 
@@ -243,16 +293,14 @@ def print_structural_toc(structural_toc: list, print_bool: bool = False) -> str:
         A formatted string of the structural TOC.
     """
     lines = []
-    lines.append("\n" + "=" * 70)
+    lines.append("\n" + "=" * SEP_COUNT)
     lines.append("## Structural Table of Contents (PDF Bookmarks/Outline)")
-    lines.append("=" * 70)
+    lines.append("=" * SEP_COUNT)
 
     if not structural_toc:
         msg = "No structural TOC (bookmarks/outline) found."
         lines.append(msg)
         output = "\n".join(lines)
-        if print_bool:
-            print(output)
         return output
 
     # Determine max page width for consistent alignment
@@ -269,12 +317,36 @@ def print_structural_toc(structural_toc: list, print_bool: bool = False) -> str:
         
         lines.append(f"{indent}{item['title']} . . . page {page_str}")
 
-    lines.append("-" * 70)
+    lines.append("-" * SEP_COUNT)
     
     # Final aggregation
     str_structural_toc = "\n".join(lines)
-    
-    if print_bool:
-        print(str_structural_toc)
         
     return str_structural_toc
+
+if __name__ == "__main__":
+
+    from pdflinkcheck.io import get_first_pdf_in_cwd
+    pdf_path = get_first_pdf_in_cwd()
+    # Run analysis first
+
+    if pymupdf_is_available():
+        pdf_library = "pymupdf"
+    else:
+        pdf_library = "pypdf"
+    report = run_report(
+        pdf_path=pdf_path,
+        max_links=0,
+        export_format="",
+        pdf_library=pdf_library,
+        print_bool=True  # We handle printing in validation
+    )
+
+    if not report or not report.get("data"):
+        print("No data extracted — nothing to validate.")
+        sys.exit(1)
+
+    else:
+        print("Success!")
+        print(f"list(report['data']) = {list(report['data'])}")
+

pdflinkcheck/stdlib_server.py

@@ -1,3 +1,5 @@
+#!/usr/bin/env python3 
+# SPDX-License-Identifier: MIT
 # src/pdflinkcheck/stdlib_server.py
 import http.server
 import socketserver
@@ -8,7 +10,7 @@ import os
 from pathlib import Path
 import email  # This replaces cgi for multipart parsing
 
-from pdflinkcheck.report import run_report
+from pdflinkcheck.report import run_report_and_call_exports
 
 PORT = 8000
 
@@ -17,8 +19,8 @@ HTML_FORM = """
 <html>
 <head><title>pdflinkcheck Stdlib Server</title></head>
 <body style="font-family: sans-serif; max-width: 800px; margin: 40px auto;">
-  <h1>pdflinkcheck API (Pure Stdlib, without cgi)</h1>
-  <p>Upload a PDF for link/TOC analysis. Zero third-party deps, future-proof.</p>
+  <h1>pdflinkcheck API (pure stdlib)</h1>
+  <p>Upload a PDF for link/TOC analysis.</p>
   <form action="/" method="post" enctype="multipart/form-data">
     <p><input type="file" name="file" accept=".pdf" required></p>
     <p>
@@ -33,9 +35,13 @@ HTML_FORM = """
       <input type="number" name="max_links" value="0" min="0">
     </p>
     <p><button type="submit">Analyze PDF</button></p>
+    <!--p>
+      <button type="submit" name="action" value="analyze">Analyze PDF</button>
+      <button type="submit" name="action" value="validate">Validate PDF</button>
+    </p-->
   </form>
   <hr>
-  <p>Returns JSON. Works on Termux & Python 3.13+.</p>
+  <p>Returns JSON.</p>
 </body>
 </html>
 """
@@ -130,18 +136,20 @@ class PDFLinkCheckHandler(http.server.SimpleHTTPRequestHandler):
                 tmp_file.write(file_item)
                 tmp_path = tmp_file.name
 
-            result = run_report(
+            result = run_report_and_call_exports(
                 pdf_path=tmp_path,
                 max_links=max_links if max_links > 0 else 0,
                 export_format="",
                 pdf_library=pdf_library,
                 print_bool=False
             )
+            metadata = result.get("metadata", {"total_links": 0, "pdf_name": file_filename})
+            total_links = metadata.get("total_links", 0)
 
             response = {
                 "filename": file_filename,
                 "pdf_library_used": pdf_library,
-                "total_links": result["metadata"]["total_links"],
+                "total_links": total_links,
                 "data": result["data"],
                 "text_report": result["text"]
             }

pdflinkcheck/update_msix_version.py

@@ -0,0 +1,47 @@
+from pathlib import Path
+from pdflinkcheck.version_info import get_version_from_pyproject
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+
+UNVERSIONED_MANIFEST = PROJECT_ROOT / "msix" / "AppxManifest_unversioned.xml"
+OUTPUT_MANIFEST = PROJECT_ROOT / "msix" / "AppxManifest.xml"
+
+
+PLACEHOLDER = "@@VERSION_PLACEHOLDER@@"
+
+
+def generate_versioned_manifest(version):
+
+    # Pad to four parts: 1.1 -> 1.1.0.0, 1.1.92 -> 1.1.92.0
+    parts = version.split(".")
+    if len(parts) == 2:
+        parts += ["0", "0"]
+    elif len(parts) == 3:
+        parts.append("0")
+    elif len(parts) > 4:
+        raise ValueError(f"Version has too many parts: {version}")
+
+    msix_version = ".".join(parts[:4])
+
+    if not UNVERSIONED_MANIFEST.exists():
+        raise FileNotFoundError(f"Unversioned manifest not found: {UNVERSIONED_MANIFEST}")
+
+    text = UNVERSIONED_MANIFEST.read_text(encoding="utf-8")
+
+    placeholder_full = f'Version="{PLACEHOLDER}"'
+
+    if placeholder_full not in text:
+        raise ValueError(f"Placeholder {placeholder_full} not found in the unversioned manifest!")
+
+    updated_text = text.replace(placeholder_full, f'Version="{msix_version}"')
+
+    # Ensure the directory exists and write the new manifest
+    OUTPUT_MANIFEST.parent.mkdir(parents=True, exist_ok=True)
+    OUTPUT_MANIFEST.write_text(updated_text, encoding="utf-8")
+
+    print(f"Successfully generated AppxManifest.xml with version {msix_version}")
+
+
+if __name__ == "__main__":
+    version = get_version_from_pyproject()
+    generate_versioned_manifest(version)