Hvordan behandle store Excel-filer og generere PDF-rapporter med Python

Når det gjelder behandling av store datamengder i Excel-filer, er det viktig å benytte teknikker som ikke krever mye minne, samtidig som man opprettholder effektivitet og pålitelighet. Ved å bruke Python-biblioteket openpyxl kan vi håndtere både lesing og skriving av Excel-filer på en minneeffektiv måte. Her skal vi utforske hvordan man kan lese, prosessere og eksportere store Excel-filer, samt generere PDF-rapporter ved hjelp av verktøy som WeasyPrint.

Når vi arbeider med store Excel-filer, er det ofte viktig å benytte en lesemodus som kun holder en liten del av filen i minnet om gangen. Dette gjøres ved å bruke read_only=True i openpyxl, som gjør at filen kan åpnes uten å laste hele innholdet i minnet. Dette er avgjørende når man arbeider med filer som kan være på flere gigabyte, da det forhindrer at programmet krasjer eller bruker unødvendig mye minne.

python
Copy code
from openpyxl import load_workbook
def process_excel_with_headers(file_path, sheet_name=None):
    wb = load_workbook(file_path, read_only=True, data_only=True)
    ws = wb[sheet_name] if sheet_name else wb.active
    rows = ws.iter_rows(values_only=True)
    headers = next(rows)
    for values in rows:
        row = dict(zip(headers, values))
        handle_row(row)

Denne metoden gjør det mulig å behandle Excel-filer på samme måte som CSV-filer, samtidig som vi bevarer filens opprinnelige struktur. Dette er en praktisk tilnærming når man arbeider med datasett som er for store til å lastes helt inn i minnet.

Skriving og eksportering av Excel-filer

python
Copy code
from openpyxl import Workbook
def export_data_to_excel(rows, output_path, headers):
    wb = Workbook(write_only=True)
    ws = wb.create_sheet()
    ws.append(headers)
    for row in rows:
        ws.append([row.get(header, "") for header in headers])
    wb.save(output_path)

Ved å bruke write_only=True kan vi effektivt eksportere data som er for store til å lastes inn i minnet samtidig. Dette er spesielt nyttig når vi arbeider med tusenvis eller hundretusener av rader.

Håndtering av koding, datatyper og feil

Både Excel- og CSV-filer kan inneholde utfordringer som uforenlige tegnsett, inkonsistente kolonneantall eller blandede datatyper. For å sikre at skriptene våre er robuste, er det viktig å:

• Angi kodingen eksplisitt (UTF-8 er det tryggeste for de fleste moderne filer).

• Validere hver rad for å fange opp feil uten å bryte strømmen.

• Håndtere manglende eller ekstra kolonner ved å bruke dict.get() og standardverdier.

• Normalisere datatyper tidlig i prosessen (for eksempel konvertere numeriske strenger til tall).

Et enkelt eksempel på feilhåndtering kan være å fange unntak når vi prosesserer hver rad, slik at vi kan loggføre feil uten å stoppe programmet:

python
Copy code
def safe_handle_row(row):

    try:
        process_row(row)
    except Exception as e:
        log_error(e, row)

Ved å benytte en strømmetilnærming til lesing og skriving, kan vi behandle datasett som ellers ville krasje tradisjonelle minnebaserte metoder. Dette gjør det mulig å jobbe med store filer på maskiner med begrensede ressurser, og gir oss et verktøy som er nyttig for alt fra rask ETL-behandling til produksjonsklare webtjenester.

Generering av PDF-rapporter

For å generere PDF-er fra HTML kan vi bruke moderne verktøy som WeasyPrint, et Python-bibliotek som støtter CSS og kan konvertere HTML til PDF på en pålitelig måte. Et alternativ til WeasyPrint er å bruke headless Chrome, som gir full nettleserkraft for serverbaserte skript.

html
Copy code
<h1>{{ report_title }}</h1>
<p>Generated at: {{ generated_at }}</p>
<p>Total Transactions: {{ transactions | length }}</p>
<p>Report Author: {{ author }}</p>
<table>
  <thead>
    <tr>
      <th>Date</th>
      <th>Description</th>
      <th>Amount</th>
    </tr>
  </thead>
  <tbody>
    {% for t in transactions %}
    <tr>
      <td>{{ t.date }}</td>
      <td>{{ t.description }}</td>
      <td>{{ "%.2f"|format(t.amount) }}</td>
    </tr>
    {% endfor %}
  </tbody>
</table>

Ved å bruke denne malen kan vi generere HTML-innhold som deretter kan konverteres til en PDF ved hjelp av WeasyPrint.

python
Copy code
from weasyprint import HTML

def html_to_pdf_bytes(html: str) -> bytes:
    pdf_file = HTML(string=html).write_pdf()
    return pdf_file

Denne funksjonen tar HTML-innhold som input og returnerer en PDF-fil som en byte-strøm, klar til å lagres eller strømmes.

Effektiv levering av PDF-er

python
Copy code
from fastapi import APIRouter, Response
from fastapi.responses import StreamingResponse
import io
router = APIRouter()
@router.post("/reports/pdf")

async def generate_pdf_report(data: dict):

    transactions = data.get("transactions", [])
    html = render_report_html(transactions)
    pdf_bytes = html_to_pdf_bytes(html)
    return StreamingResponse(io.BytesIO(pdf_bytes), media_type="application/pdf")

Denne tilnærmingen gjør det mulig å levere PDF-rapporter umiddelbart, og gir en optimal brukeropplevelse.

Hvordan Generere PDF-rapporter og Håndtere Bilder i Python-applikasjoner

Å lage og generere PDF-rapporter er en essensiell ferdighet i enhver Python-applikasjon, spesielt når man jobber med data- eller forretningsrapporter. Enten det dreier seg om enkle oversikter eller store, komplekse rapporter, gir teknikkene for PDF-generering i Python en solid grunnlag for å levere dokumenter av høy kvalitet til brukerne. På samme måte krever applikasjoner som håndterer bilder - for eksempel profiler, produkter eller galerier - en effektiv måte å generere og håndtere bildeminiatyrer på. Denne artikkelen fokuserer på hvordan man kan implementere PDF-rapportgenerering og bildebehandling, inkludert oppretting av miniutgaver, i Python-applikasjoner ved hjelp av FastAPI og relevante biblioteker.

Generering av PDF-rapporter i Python

For å gjøre dette effektivt, kan man bruke en enkel FastAPI-rute som illustrert i følgende kode:

python
Copy code
author = data.get("author", "System")
title = data.get("title", "Transaction Report")
html = render_report_html(transactions, author, title)
pdf_bytes = html_to_pdf_bytes(html)
return StreamingResponse(io.BytesIO(pdf_bytes), media_type="application/pdf", headers={
    "Content-Disposition": "inline; filename=report.pdf"
})

Denne koden tar inn dataene (som transaksjoner, forfatter og tittel) og genererer en PDF-rapport som svar til brukeren. Ved å bruke asynkrone metoder kan man håndtere rapportgenerering av store eller komplekse data uten å blokkere andre prosesser i applikasjonen. Dette er spesielt viktig når man jobber med større rapporter, da det tillater en mer effektiv og skalerbar løsning. For enda større rapporter kan man dele innholdet i seksjoner og sende det i biter, eller bruke midlertidige filer som buffere.

Håndtering av Bildeopplastinger og Miniatyrbilder

Python-biblioteket Pillow er svært effektivt for å håndtere bildebehandling. Det gir et lettvekts, men kraftig verktøysett for alt fra enkel skalering til avanserte fargeendringer og metadata-preservering. Med Pillow kan vi enkelt generere miniutgaver i ulike størrelser for bilder som lastes opp til serveren. Ved å bruke FastAPI sammen med Pillow kan vi lage en effektiv rute som både lagrer det opplastede bildet og genererer nødvendige miniutgaver.

Her er et eksempel på hvordan dette kan implementeres i en FastAPI-rute:

python
Copy code
from fastapi import APIRouter, UploadFile, File, HTTPException
from PIL import Image
import os
router = APIRouter()
UPLOAD_DIR = "uploaded_images"

THUMBNAIL_SIZES = [(64, 64), (128, 128), (256, 256)]

os.makedirs(UPLOAD_DIR, exist_ok=True)
@router.post("/upload-image/")
async def upload_image(file: UploadFile = File(...)):
    if not file.content_type.startswith("image/"):
        raise HTTPException(status_code=400, detail="Invalid image format")
    file_ext = os.path.splitext(file.filename)[1].lower()
    save_path = os.path.join(UPLOAD_DIR, file.filename)
    # Save original file

    with open(save_path, "wb") as out_file:

        content = await file.read()
        out_file.write(content)
    # Generate and save thumbnails
    thumbnails = []
    try:
        image = Image.open(save_path)
        for size in THUMBNAIL_SIZES:
            thumb = image.copy()
            thumb.thumbnail(size)
            thumb_name = f"{os.path.splitext(file.filename)[0]}_{size[0]}x{size[1]}{file_ext}"
            thumb_path = os.path.join(UPLOAD_DIR, thumb_name)
            thumb.save(thumb_path)
            thumbnails.append({"size": size, "path": thumb_path})
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Image processing failed: {e}")
    return {
        "original": save_path,
        "thumbnails": thumbnails
    }

Pillow gjør det enkelt å opprette miniutgaver, og ved å bruke metoden thumbnail() kan man skalere bildene proporsjonalt, noe som sikrer at bildene ikke blir forvrengt. Hvis man ønsker mer kontroll over bildestørrelsene, kan man justere listen over miniutgavestørrelser eller til og med bruke en metode for å beskjære bildet til ønsket størrelse.

Markdown til HTML-konvertering

For å konvertere Markdown til HTML på en trygg og effektiv måte, kan man bruke bibliotekene markdown-it-py og bleach. markdown-it-py er et raskt og utvidbart Markdown-parser som gir mulighet til å konvertere Markdown-tekst til HTML, mens bleach brukes til å rense HTML-en for eventuelle sikkerhetsproblemer som kan oppstå ved utrygt brukerinnhold. Sammen gir disse bibliotekene en robust løsning for håndtering av Markdown-innhold i applikasjoner.

Etter installasjonen av nødvendige biblioteker kan vi implementere en funksjon som konverterer Markdown til HTML:

python
Copy code
from markdown_it import MarkdownIt

def markdown_to_html(markdown_text: str) -> str:

    md = MarkdownIt()
    html = md.render(markdown_text)
    return html

Denne funksjonen kan enkelt integreres i applikasjoner for å transformere brukerinnhold til HTML for visning på nettsider. Ved å bruke bleach kan vi også kontrollere hvilke HTML-elementer og attributter som er tillatt, og dermed sikre at brukerens HTML ikke inneholder skadelige elementer som kan utnyttes i XSS-angrep.

I tillegg til konvertering, bør man alltid sørge for at brukerinnhold blir sanitert og at kun trygge HTML-etiketter og attributter tillates, for å beskytte applikasjonen mot sikkerhetstrusler.