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

pdflinkcheck/tk_utils.py

@@ -0,0 +1,188 @@
+# src/pdflinkcheck/tk_utils.py
+import tkinter as tk
+import subprocess
+import re
+import platform
+
+
+
+def get_primary_monitor_geometry():
+    """ 
+    Queries xrandr to find the actual primary monitor's dimensions and offsets.
+    Returns (width, height, x_offset, y_offset) or None.
+
+    Not used.
+    """
+    try:
+        # Query xrandr for the primary monitor
+        result = subprocess.run(['xrandr', '--query'], capture_output=True, text=True, check=True)
+        # Look for a line like: "DP-0 connected primary 1920x1080+1200+0"
+        match = re.search(r'(\d+)x(\d+)\+(\d+)\+(\d+)', re.search(r'^.*primary.*$', result.stdout, re.M).group())
+        if match:
+            return map(int, match.groups())
+    except Exception:
+        return None
+
+def center_window_on_primary_stable(window: tk.Toplevel | tk.Tk, width: int, height: int):
+    """
+    Docstring for center_window_on_primary_stable
+    
+    :param window: Description
+    :type window: tk.Toplevel | tk.Tk
+    :param width: Description
+    :type width: int
+    :param height: Description
+    :type height: int
+
+    Not used.
+    """
+    window.update_idletasks()
+    
+    # 1. Try to assess via X11/XRandR (Best for WSL2)
+    geom = get_primary_monitor_geometry()
+    
+    if geom:
+        pw, ph, px, py = geom
+        print(f"[DEBUG] XRandR Primary: {pw}x{ph} at +{px}+{py}")
+    else:
+        # 2. Fallback: Center on Mouse Pointer (Best for Multi-monitor without XRandR)
+        # Since we can't find 'Primary', we put it where the user's attention is.
+        pw, ph = window.winfo_screenwidth(), window.winfo_screenheight()
+        px, py = 0, 0
+        
+        # If it's a giant span, let's just use the pointer as the anchor
+        if pw > 2500:
+            pointer_x = window.winfo_pointerx()
+            pointer_y = window.winfo_pointery()
+            # We treat a 1920x1080 box around the pointer as our 'virtual primary'
+            px, py = pointer_x - 960, pointer_y - 540
+            pw, ph = 1920, 1080
+
+    # 3. Final Math
+    x = px + (pw // 2) - (width // 2)
+    y = py + (ph // 2) - (height // 2)
+    
+    # Final clamp to ensure it's not off-screen
+    x = max(0, x)
+    y = max(0, y)
+    
+    print(f"[DEBUG] Final Positioning: x={x}, y={y}")
+    window.geometry(f"{width}x{height}+{int(x)}+{int(y)}")
+
+
+def get_monitor_geometries():
+    """
+    Queries xrandr to find all connected monitor dimensions and offsets.
+    Returns a list of dicts: [{'w', 'h', 'x', 'y', 'is_primary'}]
+    Essential for WSL2/WSLg multi-monitor accuracy.
+    
+    Active.
+    """
+    monitors = []
+    os_name = platform.system()
+
+    # --- LINUX / WSL2 Logic ---
+    if os_name == "Linux":
+        try:
+            # Run xrandr
+            xrandr_result = subprocess.run(['xrandr', '--query'], capture_output=True, text=True, check=True)
+            #print(f"xrandr_result = {xrandr_result}")
+            # Regex to find: "1920x1080+1920+0" or "1920x1080+0+0"
+            # We look for lines that contain 'connected' and a geometry string
+            lines = xrandr_result.stdout.splitlines()
+            for line in lines:
+                if " connected " in line:
+                    is_primary = "primary" in line
+                    match = re.search(r'(\d+)x(\d+)\+(\d+)\+(\d+)', line)
+                    if match:
+                        w, h, x, y = map(int, match.groups())
+                        monitors.append({
+                            'w': w, 'h': h, 'x': x, 'y': y, 
+                            'is_primary': is_primary
+                        })
+        except Exception as e:
+            print(f"[DEBUG] xrandr query failed: {e}")
+    
+    # --- WINDOWS Native Logic ---
+    if os_name == "Windows":
+        # On native Windows, we can use ctypes to call GetSystemMetrics
+        # or rely on the fact that the Primary monitor is almost always at 0,0
+        # and its size is reported by winfo_screenwidth if we don't have multiple monitors
+        # (For true multi-monitor on native Windows, win32api is usually needed)
+        pass
+        
+    return monitors
+
+def center_window_on_primary_goose(window: tk.Toplevel | tk.Tk, width: int, height: int):
+    """
+    Standardizes window centering by identifying the physical monitor 
+    bounds and offsets.
+    
+    :param window: Description
+    :type window: tk.Toplevel | tk.Tk
+    :param width: Description
+    :type width: int
+    :param height: Description
+    :type height: int
+    
+    Active.
+    """
+    window.update_idletasks()
+    
+    monitors = get_monitor_geometries()
+    target_monitor = None
+
+    if monitors:
+        # 1. Prefer the one explicitly marked 'primary'
+        target_monitor = next((m for m in monitors if m['is_primary']), None)
+        
+        # 2. Fallback to the first monitor (usually the one at +0+0)
+        if not target_monitor:
+            target_monitor = monitors[0]
+            
+        print(f"[DEBUG] Assessed Monitor: {target_monitor['w']}x{target_monitor['h']} at +{target_monitor['x']}+{target_monitor['y']}")
+    else:
+        print("[DEBUG] No monitors found via xrandr. Falling back to screenwidth.")
+        # Total fallback: use winfo_screenwidth but assume 1080p width 
+        # to avoid the L-gap if it's clearly a massive span.
+        sw = window.winfo_screenwidth()
+        sh = window.winfo_screenheight()
+        target_monitor = {
+            'w': 1920 if sw > 2500 else sw,
+            'h': 1080 if sh > 2000 else sh,
+            'x': 0, 'y': 0
+        }
+
+    # 3. Calculate Center relative to the identified monitor's geometry
+    x = target_monitor['x'] + (target_monitor['w'] // 2) - (width // 2)
+    y = target_monitor['y'] + (target_monitor['h'] // 2) - (height // 2)
+
+    print(f"[DEBUG] Final Positioning: x={x}, y={y}")
+    window.geometry(f"{width}x{height}+{int(x)}+{int(y)}")
+
+def center_window_on_primary(window: tk.Toplevel | tk.Tk, width: int, height: int):
+    window.update_idletasks()
+    monitors = get_monitor_geometries()
+    
+    target = None
+    if monitors:
+        target = next((m for m in monitors if m['is_primary']), monitors[0])
+    
+    if target:
+        # Use the precisely assessed hardware monitor
+        x = target['x'] + (target['w'] // 2) - (width // 2)
+        y = target['y'] + (target['h'] // 2) - (height // 2)
+    else:
+        # Fallback for Windows/Mac where xrandr doesn't exist
+        # We use wm_maxsize which is surprisingly accurate for the 'Primary' on Windows/Mac
+        pw, ph = window.wm_maxsize()
+        
+        # If maxsize is also reporting the huge span (rare on native), 
+        # then we use your 1920/1080 safe-zone heuristic.
+        if pw > 2500:
+            pw, ph = 1920, 1080
+
+        x = (pw // 2) - (width // 2)
+        y = (ph // 2) - (height // 2)
+
+    window.geometry(f"{width}x{height}+{int(x)}+{int(y)}")

pdflinkcheck/update_msix_version.py

@@ -1,3 +1,5 @@
+# src/pdflinkcheck/update_msix_version.py
+from __future__ import annotations
 from pathlib import Path
 from pdflinkcheck.version_info import get_version_from_pyproject
 

pdflinkcheck/validate.py

@@ -1,29 +1,34 @@
 #!/usr/bin/env python3 
 # SPDX-License-Identifier: MIT
 # src/pdflinkcheck/validate.py
-
+from __future__ import annotations
 import sys
 from pathlib import Path
 from typing import Dict, Any
 
 from pdflinkcheck.io import get_friendly_path
-from pdflinkcheck.environment import pymupdf_is_available
+from pdflinkcheck.helpers import PageRef  # Importing the established helper
 
 SEP_COUNT=28
 
+START_INDEX = 0  
+# Internal 0-based start
+# Define the offset. 
+# The PDF engines are 0-based.
+# We will add +1 only for the HUMAN REASON strings.
+
+
 def run_validation(
     report_results: Dict[str, Any],
     pdf_path: str,
-    pdf_library: str = "pypdf",
     check_external: bool = False
 ) -> Dict[str, Any]:
     """
-    Validates links during run_report() using a partial completion of the data dict.
+    Validates links during run_report_*() using a partial completion of the data dict.
 
     Args:
         report_results: The dict returned by run_report_and_call_exports()
         pdf_path: Path to the original PDF (needed for relative file checks and page count)
-        pdf_library: Engine used ("pypdf" or "pymupdf")
         check_external: Whether to validate HTTP URLs (requires network + requests)
 
     Returns:
@@ -34,30 +39,17 @@ def run_validation(
 
     all_links = data.get("external_links", []) + data.get("internal_links", [])
     toc = data.get("toc", [])
+    total_pages = metadata.get("file_overview", {}).get("total_pages",None)
 
     if not all_links and not toc:
         print("No links or TOC to validate.")
         return {"summary-stats": {"valid": 0, "broken": 0}, "issues": []}
 
-    # Get total page count (critical for internal validation)
-    try:
-        if pymupdf_is_available() and pdf_library == "pymupdf":
-            import fitz
-            doc = fitz.open(pdf_path)
-            total_pages = doc.page_count
-            doc.close()
-        else:
-            from pypdf import PdfReader
-            reader = PdfReader(pdf_path)
-            total_pages = len(reader.pages)
-    except Exception as e:
-        print(f"Could not determine page count: {e}")
-        total_pages = None
 
     pdf_dir = Path(pdf_path).parent
 
     issues = []
-    valid_count = 0
+    valid_count = 0 # add more granulaity for types of valid links
     file_found_count = 0
     broken_file_count = 0
     broken_page_count = 0
@@ -68,37 +60,56 @@ def run_validation(
 
     # Validate active links
     #print("DEBUG validate: entering loop with", len(all_links), "links")
-    for i, link in enumerate(all_links):
+    for link in all_links:
         link_type = link.get("type")
         status = "valid"
         reason = None
+
         if link_type in ("Internal (GoTo/Dest)", "Internal (Resolved Action)"):
             dest_page_raw = link.get("destination_page")
-            if dest_page_raw is None:
-                status = "no-destinstion-page"
-                reason = "No destination page resolved"
-            else:
+
+            if dest_page_raw is not None:
+
                 try:
-                    target_page = int(dest_page_raw)
-                    #target_page = int(link.get("destination_page"))
-                    if not isinstance(target_page, int):
+                    # Use PageRef to handle translation
+                    target_page_ref = PageRef.from_index(int(dest_page_raw))
+                    #target_page = int(dest_page_raw)
+                    
+                    # 1. Immediate Failure: Below 0
+                    if target_page_ref.machine < START_INDEX:
                         status = "broken-page"
-                        reason = f"Target page not a number: {target_page}"
-                    elif (1 <= target_page) and total_pages is None:
+                        # We use target_page + 1 to show the user what they "saw"
+                        reason = f"Target page {target_page_ref.human} is invalid (negative index)."
+
+                    # 2. Case: We don't know the max page count
+                    elif total_pages is None:
+                        # If it's 0 or higher, we assume it might be okay but can't be sure
                         status = "unknown-reasonableness"
-                        reason = "Total page count unavailable, but the page number is reasonable"
-                    elif (1 <= target_page <= total_pages):
-                        status = "valid"
-                        reason = f"Page {target_page} within range (1–{total_pages})"
-                    elif target_page < 1:
-                        status = "broken-page"
-                        reason = f"TOC targets page negative {target_page}."
-                    elif not (1 <= target_page <= total_pages):
+                        reason = f"Page {target_page_ref.human} seems reasonable, but total page count is unavailable."
+
+                    # 3. Case: Out of Upper Bounds
+                    elif target_page_ref.machine >= total_pages:
                         status = "broken-page"
-                        reason = f"Page {target_page} out of range (1–{total_pages})"
+                        # User sees 1-based, e.g., "Page 101 out of range (1-100)"
+                        reason = f"Page {target_page_ref.human} out of range (1–{total_pages})"
+
+                    # 4. Case: Perfect Match
+                    else:
+                        status = "valid"
+                        reason = f"Page {target_page_ref.human} within range (1–{total_pages})"
+
+                except (ValueError, TypeError):
+                    status = "broken-page"
+                    reason = f"Invalid page value: {dest_page_raw}"
+
                 except (ValueError, TypeError):
                     status = "broken-page"
                     reason = f"Invalid page value: {dest_page_raw}"
+
+            elif dest_page_raw is None:
+                status = "no-destinstion-page"
+                reason = "No destination page resolved"
+
         elif link_type == "Remote (GoToR)":
             remote_file = link.get("remote_file")
             if not remote_file:
@@ -149,40 +160,62 @@ def run_validation(
         elif status == "no-destinstion-page":
             no_destination_page_count += 1
             issues.append(link_with_val)
+
     # Validate TOC entries
     for entry in toc:
-        target_page = int(entry.get("target_page"))
-        if isinstance(target_page, int):
-            if (1 <= target_page) and total_pages is None:
-                reason = "Page count unknown"
+        try:
+            # Coerce to int; we expect 0-based index from the engine
+            # In the context of the ing Map, -1 acts as a "Sentinel Value." It represents a state that is strictly outside the "Machine" range
+            target_page_raw = int(entry.get("target_page", -1))
+            target_page_ref = PageRef.from_index(int(target_page_raw))
+
+            status = "valid"
+            reason = ""
+
+            # 1. Check for negative indices (anything below our START_INDEX)
+            if target_page_ref.machine < START_INDEX:
+                status = "broken-page"
+                broken_page_count += 1
+                # User sees Page 0 or lower as the problem
+                reason = f"TOC targets invalid page number: {target_page_ref.human}"
+
+            # 2. Case: total_pages is unknown
+            elif total_pages is None:
                 status = "unknown-reasonableness"
                 unknown_reasonableness_count += 1
-            elif target_page < 1:
+                reason = f"Page {target_page_ref.human} unknown (could not verify total pages)"
+
+            # 3. Case: Out of range (Upper Bound)
+            # Index 100 in a 100-page doc (total_pages=100) is out of bounds
+            elif target_page_ref.machine >= total_pages:
                 status = "broken-page"
-                broken_count += 1
-                reason = f"TOC targets negative page: {target_page}."
-            elif 1 <= target_page <= total_pages:
+                broken_page_count += 1
+                reason = f"TOC targets page {target_page_ref.human} (out of 1–{total_pages})"
+
+            # 4. Valid Case
+            else:
+                status = "valid"
                 valid_count += 1
+                # We skip issues.append for valid TOC entries to keep the issues list clean
                 continue
-            else:
-                status = "broken-page"
-                reason = f"TOC targets page {target_page} (out of 1–{total_pages})"
-                broken_count += 1
-        else:
+
+        except (ValueError, TypeError):
             status = "broken-page"
-            reason = f"Invalid page: {target_page}"
-            broken_count += 1
+            broken_page_count += 1
+            reason = f"Invalid page reference: {entry.get('target_page')}"
 
+        # Only reaches here if status is not "valid" (because of 'continue' above)
         issues.append({
             "type": "TOC Entry",
-            "title": entry["title"],
-            "level": entry["level"],
-            "target_page": target_page,
+            "title": entry.get("title", "Untitled"),
+            "level": entry.get("level", 0),
+            "target_page": target_page_ref.machine, # Stored as 0-indexed for data consistency
             "validation": {"status": status, "reason": reason}
         })
-
+    
+    total_checked = metadata.get("link_counts",{}).get("total_links_count",0) + metadata.get("link_counts",{}).get("toc_entry_count",0)
     summary_stats = {
-        "total_checked": len(all_links) + len(toc),
+        "total_checked": total_checked,
         "valid": valid_count,
         "file-found": file_found_count,
         "broken-page": broken_page_count,
@@ -190,8 +223,7 @@ def run_validation(
         "no_destination_page_count": no_destination_page_count,
         "unknown-web": unknown_web_count,
         "unknown-reasonableness": unknown_reasonableness_count,
-        "unknown-link": unknown_link_count,
-        #"unknown": len(all_links) + len(toc) - valid_count - broken_count # nah this is not granuar enough 
+        "unknown-link": unknown_link_count 
     }
 
     
@@ -211,7 +243,9 @@ def run_validation(
         log(f"PDF Path = {get_friendly_path(pdf_path)}")
         log(f"Total items checked: {summary_stats['total_checked']}")
         log(f"✅ Valid: {summary_stats['valid']}")
-        log(f"🌐 Web Addresses (Not Checked): {summary_stats['unknown-web']}")
+        #log(f"✅ Valid: {summary_stats['valid']}")
+        #log(f"✅ Valid: {summary_stats['valid']}")
+        log(f"🌐 Web Addresses (Ping Each: OFF): {summary_stats['unknown-web']}")
         log(f"⚠️ Unknown Page Reasonableness (Due to Missing Total Page Count): {summary_stats['unknown-reasonableness']}")
         log(f"⚠️ Unsupported PDF Links: {summary_stats['unknown-link']}")
         log(f"❌ Broken Page Reference (Page number beyond scope of availability): {summary_stats['broken-page']}")
@@ -230,6 +264,14 @@ def run_validation(
                 log("{:<5} | {:<12} | {:<30} | {}".format(i, link_type, text, reason))
             if len(issues) > 25:
                 log(f"... and {len(issues) - 25} more issues")
+
+        elif summary_stats.get('total_checked', 0) == 0:
+            # Check if this was a total crash or just an empty PDF
+            if summary_stats.get('is_error_fallback'): 
+                 log("\nStatus: Validation could not be performed due to a processing error.")
+            else:
+                 log("\nStatus: No links or TOC entries were found to validate.")
+
         else:
             log("Success: No broken links or TOC issues!")
 
@@ -249,111 +291,3 @@ def run_validation(
     }
 
     return validation_results
-
-
-def run_validation_more_readable_slop(pdf_path: str = None, pdf_library: str = "pypdf", check_external_links:bool = False) -> Dict[str, Any]:
-    """
-    Experimental. Ignore for now.
-
-    Extends the report logic by programmatically testing every extracted link.
-    Validates Internal Jumps (page bounds), External URIs (HTTP status), 
-    and Launch actions (file existence).
-    """
-    if check_external_links:
-        import requests
-
-    # 1. Setup Library Engine (Reuse logic)
-    pdf_library = pdf_library.lower()
-    if pdf_library == "pypdf":
-        from pdflinkcheck.analyze_pypdf import extract_links_pypdf as extract_links
-    else:
-        from pdflinkcheck.analyze_pymupdf import extract_links_pymupdf as extract_links
-
-    if pdf_path is None:
-        pdf_path = get_first_pdf_in_cwd()
-    
-    if not pdf_path:
-        print("Error: No PDF found for validation.")
-        return {}
-
-    print(f"\nValidating links in {Path(pdf_path).name}...")
-
-    # 2. Extract links and initialize validation counters
-    links = extract_links(pdf_path)
-    total_links = len(links)
-    results = {"valid": [], "broken": [], "error": []}
-
-    # 3. Validation Loop
-    for i, link in enumerate(links, 1):
-        # Progress indicator for long manuals
-        sys.stdout.write(f"\rChecking link {i}/{total_links}...")
-        sys.stdout.flush()
-
-        link_type = link.get('type')
-        status = {"is_valid": False, "reason": "Unknown Type"}
-
-        # --- A. Validate Internal Jumps ---
-        if "Internal" in link_type:
-            target_page = link.get('destination_page')
-            if isinstance(target_page, int) and target_page > 0:
-                # In a real run, you'd compare against reader.pages_count
-                status = {"is_valid": True, "reason": "Resolves"}
-            else:
-                status = {"is_valid": False, "reason": f"Invalid Page: {target_page}"}
-
-        # --- B. Validate Web URIs ---
-        elif link_type == 'External (URI)':
-
-            url = link.get('url')
-            if url and url.startswith("http") and check_external_links:
-                try:
-                    # Use a short timeout and HEAD request to be polite/fast
-                    resp = requests.head(url, timeout=5, allow_redirects=True)
-                    if resp.status_code < 400:
-                        status = {"is_valid": True, "reason": f"HTTP {resp.status_code}"}
-                    else:
-                        status = {"is_valid": False, "reason": f"HTTP {resp.status_code}"}
-                except Exception as e:
-                    status = {"is_valid": False, "reason": "Connection Failed"}
-            else:
-                status = {"is_valid": False, "reason": "Malformed URL"}
-
-        # --- C. Validate Local File/Launch Links ---
-        elif link_type == 'Launch' or 'remote_file' in link:
-            file_path = link.get('remote_file') or link.get('url')
-            if file_path:
-                # Clean URI formatting
-                clean_path = file_path.replace("file://", "").replace("%20", " ")
-                # Check relative to the PDF's location
-                abs_path = Path(pdf_path).parent / clean_path
-                if abs_path.exists():
-                    status = {"is_valid": True, "reason": "File Exists"}
-                else:
-                    status = {"is_valid": False, "reason": "File Missing"}
-
-        # Append result
-        link['validation'] = status
-        if status['is_valid']:
-            results['valid'].append(link)
-        else:
-            results['broken'].append(link)
-
-    print("\n" + "=" * SEP_COUNT)
-    print(f"--- Validation Summary Stats for {Path(pdf_path).name} ---")
-    print(f"Total Checked: {total_links}")
-    print(f"✅ Valid:  {len(results['valid'])}")
-    print(f"❌ Broken: {len(results['broken'])}")
-    print("=" * SEP_COUNT)
-
-    # 4. Print Detail Report for Broken Links
-    if results['broken']:
-        print("\n## ❌ Broken Links Found:")
-        print("{:<5} | {:<5} | {:<30} | {}".format("Idx", "Page", "Reason", "Target"))
-        print("-" * SEP_COUNT)
-        for i, link in enumerate(results['broken'], 1):
-            target = link.get('url') or link.get('destination_page') or link.get('remote_file')
-            print("{:<5} | {:<5} | {:<30} | {}".format(
-                i, link['page'], link['validation']['reason'], str(target)[:30]
-            ))
-    
-    return results

pdflinkcheck/version_info.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3 
 # SPDX-License-Identifier: MIT
 # src/pdflinkcheck/version_info.py
-
+from __future__ import annotations
 import re
 from pathlib import Path
 import sys
@@ -83,4 +83,4 @@ def get_version_from_pyproject() -> str:
         match = re.search(r'version\s*=\s*["\']([^"\']+)["\']', poetry_section.group(1))
         if match: return match.group(1)
 
-    return "0.0.0"
+    return "0.0.0"