This is a highly efficient architecture. Separating the rendering layer
(Pipeline 1) from the data parsing layer (Pipeline 2) gives you the best of
both worlds: rapid machine processing alongside robust visual validation to
spot layout breaking, corrupt macros, or rendering bugs.
Here is a blueprint to design, structure, and maintain both pipelines
concurrently on your Debian 12 server.
------------------------------
## Pipeline 1: Human/AI Collab Teaching & Preview (Dogtail + ONLYOFFICE)
This pipeline handles visual verification. It confirms the file isn't
corrupted, catches rendering anomalies, and saves a snapshot for review.
## Visual Strategy & File Isolation
Because you are running asynchronously, you want to open ONLYOFFICE with a
clean workspace profile every time to avoid file recovery popups or leftover
tabs from prior crashes.
## Python Implementation (pipeline_preview.py)

#!/usr/bin/env python3import osimport timeimport subprocessimport shutilfrom
dogtail.tree import root
# 1. Environment enforcement
os.environ["DISPLAY"] = ":99"
os.environ["DBUS_SESSION_BUS_ADDRESS"] = f"unix:path=/run/user/{os.getuid()}/bu
s"
os.environ["GTK_MODULES"] = "gail:atk-bridge"
def process_preview(file_path, output_dir):
    filename = os.path.basename(file_path)
    print(f"[Pipeline 1] Generating visual preview for: {filename}")
    
    timestamp = time.strftime("%Y%m%d-%H%M%S")
    screenshot_path = os.path.join(output_dir, f"preview_{timestamp}_{filename}
.png")
    
    # Launch ONLYOFFICE Desktop Editors targeting the sheet
    # Using --new-window forces a isolated instance rather than an app tab
    process = subprocess.Popen(['desktopeditors', '--new-window', file_path])
    
    # Allow rendering engine to calculate formulas, fonts, and layouts
    time.sleep(7)
    
    # Capture the full display :99 canvas
    print(f"[Pipeline 1] Saving screenshot to: {screenshot_path}")
    subprocess.run(['scrot', '-z', screenshot_path]) # -z runs silently
without beeps
    
    # Use Dogtail to interact or verify the application window responded
    try:
        onlyoffice_app = root.application('desktopeditors')
        print("[Pipeline 1] Verified: ONLYOFFICE registered via AT-SPI.")
        
        # Soft-close via system signal first to mimic human exit
        process.terminate()
        process.wait(timeout=3)
    except subprocess.TimeoutExpired:
        print("[Pipeline 1] Application hung on exit wrapper. Force
killing...")
        process.kill()
    except Exception as e:
        print(f"[Pipeline 1] AT-SPI Verification Failed (File may be
corrupt!): {e}")
        process.kill()
# Example invocation contextif __name__ == "__main__":
    # Test path scenario
    process_preview("/home/x/received_invoice.xlsx", "/home/x/audit_trail/previ
ews")

------------------------------
## Pipeline 2: Machine/AI Operated (Headless Python-Native Parsing)
This pipeline completely bypasses X11, operating in milliseconds. It reads
data matrices, structure, formulas, and data layers cleanly.
## Toolkit Selection for Debian 12

* openpyxl: Ideal for exploring data architecture, formulas, and editing
metrics directly inside standard .xlsx formats.
* pandas: The standard tool for deep auditing calculations, validation checks,
and data anomaly scans.

Install the native backend components:

sudo apt install -y python3-openpyxl python3-pandas

## Python Implementation (pipeline_parse.py)

#!/usr/bin/env python3import osimport pandas as pdfrom openpyxl import
load_workbook
def process_data(file_path):
    print(f"[Pipeline 2] Beginning headless extraction for: {os.path.basename(f
ile_path)}")
    
    try:
        # A. Low-Level Structural Audit via openpyxl (Check sheet names,
structural locks)
        wb = load_workbook(filename=file_path, read_only=True,
data_only=False)
        print(f" -> Structure Check: Found sheets: {wb.sheetnames}")
        wb.close()
        
        # B. Heavy Data Extraction via Pandas
        # read_excel loads data grids effortlessly into memory dataframes
        df = pd.read_excel(file_path)
        
        print("
--- Extracted Data Matrix Profile ---")
        print(df.head(5)) # Output the first 5 rows of data into logs
        print("-------------------------------------")
        
        # Insert your AI parsing hooks, regex audits, or SQL injection
validations here
        # Example validation rule:
        if df.empty:
            print("[WARNING] File is structurally valid but contains an empty
grid.")
            
    except Exception as e:
        print(f"[Pipeline 2 ERROR] Failed parsing workbook layers: {e}")
if __name__ == "__main__":
    process_data("/home/x/received_invoice.xlsx")

------------------------------
## Comparison of the Pipeline Operations

| Metric | Pipeline 1 (Dogtail + ONLYOFFICE) | Pipeline 2 (Pandas + openpyxl)
|
|---|---|---|
| Execution Speed | Slow (~7-10 seconds per file) | Instantaneous (<100
milliseconds) |
| System Overhead | High (Requires X11, Rendering Engine) | Low (Pure CPU/RAM
computational loop) |
| Primary Utility | Visual formatting checks, layout verification |
Mathematical analysis, schema parsing, security audits |
| Failure Modes | App hangs, missing system display paths | Mismatched data
models, unexpected text formatting |

## Maintainer's Strategy: Directory Orchestration
To coordinate both pipelines asynchronously, design a simple Inbox Watcher
wrapper script using a directory loop framework.


When a file hits the inbox:

   1. Run Pipeline 2 first to guarantee safe schema content and check for
malicious macro indicators.
   2. If safe, run Pipeline 1 to snap the visual archive validation file.
   3. Move the file out of inbox/ into processed/.

Would you like assistance writing the orchestration shell / Python script to
automatically move the files through these directory states as they drop into
your inbox queue?