Python og FastAPI: Når JavaScript ikke er nok

Det er et punkt i mange prosjekter der du innser at JavaScript-økosystemet ikke har det du trenger. For meg skjer det oftest med databehandling. Å parse store datasett, transformere formater, kjøre statistiske beregninger — Python gjør dette på ti linjer der Node.js trenger femti og tre npm-pakker.

Python er ikke hovedspråket mitt. TypeScript og React er der jeg lever til daglig. Men jeg har lært å verdsette Python som det det er: et verktøy der avstanden mellom idé og fungerende kode er kortere enn noe annet jeg har jobbet med.

Datapipelines: Der Python virkelig skinner

I arbeidet med NEXT Utdanning bygget jeg datapipelines som prosesserer kursdata — henter fra eksterne kilder, transformerer formater, validerer innhold og laster inn i databasen. Med biblioteker som pandas og requests er denne typen arbeid nesten trivielt.

Generatorer er en av Pythons sterkeste sider for databehandling. De lar deg prosessere store datamengder uten å laste alt i minnet:

from typing import Generator
import json

def read_records(path: str) -> Generator[dict, None, None]:
    with open(path) as f:
        for line in f:
            yield json.loads(line)

def validate(records: Generator[dict, None, None]) -> Generator[dict, None, None]:
    for record in records:
        if record.get("title") and record.get("content"):
            yield record

def enrich(records: Generator[dict, None, None]) -> Generator[dict, None, None]:
    for record in records:
        record["word_count"] = len(record["content"].split())
        yield record

raw = read_records("courses.jsonl")
valid = validate(raw)
enriched = enrich(valid)

for record in enriched:
    process(record)

Hver funksjon er et steg i pipelinen. Data flyter gjennom generatorer — kun én rad i minnet om gangen, uansett om filen er 100 eller 100 000 linjer. Det som imponerer meg med dette mønsteret er hvor komposerbart det er: du kan legge til filtrering, transformasjon eller logging ved å wrappe en ny generator rundt de eksisterende.

FastAPI: Typesikker Python for API-er

Når en datapipeline trenger et API foran seg, er FastAPI mitt valg. Det tar alt jeg liker ved TypeScript — typesikkerhet, validering, dokumentasjon som kode — og bringer det til Python.

Pydantic-modeller fungerer som kontrakter mellom klient og server:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from datetime import datetime

app = FastAPI(title="Content Pipeline API")

class ContentRequest(BaseModel):
    title: str = Field(min_length=1, max_length=200)
    body: str = Field(min_length=10)
    format: str = Field(pattern="^(markdown|html|plain)$")
    language: str = Field(default="no", pattern="^(no|en)$")

class ContentResponse(BaseModel):
    id: str
    title: str
    word_count: int
    processed_at: datetime

@app.post("/content/process", response_model=ContentResponse)
async def process_content(req: ContentRequest):
    word_count = len(req.body.split())
    if word_count < 50:
        raise HTTPException(status_code=422, detail="Content too short for processing")

    result = await pipeline.process(req.title, req.body, req.format, req.language)

    return ContentResponse(
        id=result.id,
        title=req.title,
        word_count=word_count,
        processed_at=datetime.now(),
    )

Det som gjør FastAPI spesielt er at alt henger sammen. Pydantic-modellene driver validering, serialisering og dokumentasjon. Starter du serveren, har du Swagger UI på /docs gratis — alltid oppdatert, ingen manuelt vedlikehold. For noen som kommer fra TypeScript-verdenen føles denne tilnærmingen umiddelbart kjent.

Dependency injection-systemet er elegant for ting som databasesesjoner — du definerer en Depends()-funksjon, og FastAPI sørger for at ressurser åpnes og lukkes riktig. Det er det samme prinsippet som constructor injection i Go eller providers i React, bare uttrykt annerledes.

Når jeg velger Python over JavaScript

Tommelregelen min er enkel:

• Databehandling: Pandas, numpy, og Pythons generator-mønster gjør dataarbeid trivielt.
• Rask prototyping: Når jeg trenger å validere en idé raskt og ikke vet om den overlever uken.
• Engangsskript: Datamigering, filkonvertering, rapportgenerering. Ti linjer Python slår hundre linjer TypeScript.
• ML/AI-integrasjon: Python-økosystemet for maskinlæring er uovertruffent.

Og når jeg ikke velger Python:

• Produksjonstjenester med høy trafikk: Go er bedre for ren throughput.
• Frontend-tung utvikling: Da holder jeg hele stacken i TypeScript for konsistens.
• Når teamet kan JavaScript: Å introdusere et ekstra språk har en kostnad.

Det handler om å kjenne verktøykassen

Jeg later ikke som jeg er en Python-ekspert. Det jeg forstår er når Python er riktig valg og hvorfor. Generatorer for minneeffektiv databehandling. Pydantic for typesikker validering. FastAPI for å bygge API-er raskt uten å gi opp kvalitet.

Det er ikke det raskeste språket. Det er ikke det jeg bygger produksjonssystemer i. Men for riktig problem er det vanskelig å argumentere mot.