# From Raw Text to Cryptographic Seal: Building a Legal Document Factory in Python

> Source: <https://dev.to/sunverseai/from-raw-text-to-cryptographic-seal-building-a-legal-document-factory-in-python-4ldn>
> Published: 2026-08-09 21:15:08+00:00

When people think of Artificial Intelligence, they usually think of chat boxes. You type a prompt, text scrolls across the screen, and you copy-paste it.

In the legal world, a chat box isn't enough. A contract on a screen is just a suggestion. **A contract in hand—signed, sealed, and cryptographically verified—is a binding asset.**

As we build **Lawyie** (Sunverse AI’s intelligent legal infrastructure for Africa), one of our core mandates was moving beyond the chat interface. We needed a Document Factory.

Here is the engineering breakdown of how we built an in-memory PDF generation pipeline that creates cryptographically-sealed legal documents in Python.

**1. The Problem with Standard File Writing**

In standard Python web apps, saving a file usually means writing it to the local hard drive and then serving it.

In a cloud environment like Streamlit Cloud, doing this at scale causes concurrency issues (multiple users overwriting the same `contract.pdf`

file) and unnecessary disk read/write latency.

The Solution: Everything must happen in-memory.

**2. The In-Memory Buffer ( io.BytesIO / Byte-Streams)**

`io`

module to capture the PDF output directly as a byte-stream and feed it straight into the user's browser download button.Here is how the pipeline works using `fpdf2`

:

``` python
from fpdf import FPDF
import io

def generate_legal_pdf(contract_text, signature_id):
    # 1. Initialize the PDF engine
    pdf = FPDF()
    pdf.add_page()
    pdf.set_font("Arial", size=11)

    # 2. Clean text (Handling special characters for Latin-1 encoding)
    clean_text = contract_text.replace("₦", "NGN").replace("—", "-")
    final_content = f"{clean_text}\n\nSECURE HASH ID: {signature_id}"

    # 3. Write to the document
    pdf.multi_cell(0, 10, txt=final_content)

    # 4. Capture the output as bytes (Crucial for fpdf2)
    pdf_output = pdf.output()
    pdf_bytes = bytes(pdf_output) if isinstance(pdf_output, bytearray) else pdf_output

    return pdf_bytes
```

**3. Cryptographic E-Signatures ( hashlib)**

We solved this by generating a unique **SHA-256 Hash ID** tied to the user's name and the exact timestamp of generation.

``` python
import hashlib
from datetime import datetime

def generate_e_signature(name):
    timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
    # Generate a secure 12-character cryptographic hash
    raw_string = f"{name}{timestamp}"
    sig_hash = hashlib.sha256(raw_string.encode()).hexdigest()[:12].upper()

    return f"SIGNED-BY-{name.upper()}-ID-{sig_hash}"
```

This hash acts as a **digital fingerprint**. If even a single comma in the contract changes, the hash changes, proving authenticity.

**4. Why This Matters for African Legal-Tech**

By combining LLM inference (Groq) with an automated document factory (Python + FPDF2), Lawyie reduces the time it takes to draft, review, and seal a compliant SME contract from 3 days to 5 seconds.

For the 1.4 billion people of Africa, this isn't just about writing cleaner code. It’s about removing the economic barriers that keep millions operating in the "legal shadow."

**What’s Next?**

We are continuing to scale Lawyie from Abuja, optimizing our Supabase vault, and expanding our multi-language support.

If you're building document automation tools in Python, let's connect in the comments!

Try Lawyie Live: [lawyie.streamlit.app]