Hur Python Type Hints och Pydantic Förbättrar Kodkvalitet och Prestanda i Webbutveckling

Python, ett av de mest populära programmeringsspråken, har länge varit känd för sin enkelhet och läsbarhet. Trots detta har det under åren fått mer avancerade funktioner, särskilt i relation till typannotering och datavalidering. Dessa funktioner spelar en central roll för att säkerställa att koden är korrekt, lättläst och effektiv. Två viktiga verktyg för detta syfte är Python’s typhinting-system och Pydantic, ett kraftfullt bibliotek för datavalidering, särskilt användbart i webbutveckling med ramverket FastAPI.

python
Copy code
from typing import Union
x: Union[str, int]

Det moderna och mer kortfattade sättet att uttrycka samma sak ser ut så här:

python
Copy code
x: str | int

Sådana typanvisningar ger utvecklare och verktyg som linters en bättre förståelse för koden, vilket leder till färre fel och mer förutsägbart beteende. Python’s typing-modul erbjuder flera användbara generiska typer, såsom List, Dict, Callable och Iterator, som kan användas för att uttrycka olika datatyper och funktionaliteter i koden på ett tydligt sätt.

python
Copy code
from typing import Literal
account_type: Literal["personal", "business"]
account_type = "name"  # Mypy kommer här att ge ett fel, eftersom "name" inte är ett giltigt värde.

Typanvisningar som dessa, även om de är frivilliga i Python, bidrar till att förhindra logiska fel i koden. Det gör det också möjligt för utvecklare att fånga potentiella buggar redan vid utvecklingstid, snarare än vid körning.

När det gäller hantering av tid och datum kan Python’s typhinting också spela en viktig roll. Ett exempel på detta är att ange att en funktion tar ett datetime-objekt som indata och returnerar en sträng:

python
Copy code
from datetime import datetime

def format_datetime(dt: datetime) -> str:
    return dt.strftime("%Y-%m-%d %H:%M:%S")
now = datetime.now()
print(format_datetime(now))

Denna typ av typning hjälper utvecklare att snabbt förstå vad varje funktion förväntar sig och vad den kommer att returnera, vilket förbättrar både produktiviteten och kodens läsbarhet.

För mer komplexa datatyper, som en lista med ordböcker, kan man använda typhinting för att uttrycka en sådan struktur, vilket gör koden mer självdokumenterande och lättare att underhålla:

python
Copy code
def get_users(id: int) -> list[dict]:

    return [
        {"id": 1, "name": "Alice"},
        {"id": 2, "name": "Bob"},
        {"id": 3, "name": "Charlie"},
    ]

När det gäller Pydantic, ett bibliotek som ofta används i samband med FastAPI, är det ett kraftfullt verktyg för att validera och bearbeta data. Pydantic använder Python’s typhinting-system och ger utvecklare möjlighet att modellera data på ett mycket detaljerat sätt. Detta gör det möjligt att både validera indata och säkerställa att de överensstämmer med de specifikationer som har definierats.

Fördelarna med att använda Pydantic är många:

• Det bygger på standard Python-typer, vilket gör det lätt att använda och förstå.

• Eftersom Pydantic är optimerat för hastighet och dess kärnkomponenter är skrivna i Rust, kan det hantera stora mängder data snabbt och effektivt.

• Det finns stort stöd från utvecklarsamhället, och Pydantic används ofta tillsammans med populära Python-ramverk som Django Ninja och SQLModel.

• Pydantic gör det enkelt att generera JSON-scheman, vilket underlättar integration med andra system.

FastAPI och Pydantic tillsammans gör det möjligt att bygga mycket snabba och effektiva webbtjänster, där all data som tas emot från användare eller externa API:er valideras och säkerställs utan att påverka prestandan. Detta gör att utvecklare kan fokusera mer på applikationens funktionalitet snarare än att ständigt hantera fel och datavalidering.

Hur man skapar en REST API med autentisering och användarhantering i FastAPI

För att bygga en funktionell och säker backendapplikation är det avgörande att integrera autentisering och hantering av användardata. Ett vanligt sätt att implementera detta är genom att använda JSON Web Tokens (JWT) och skapa en användarmodell som möjliggör användarinloggning och rättighetskontroll. Här följer en genomgång av hur man skapar en REST API i FastAPI som stöder bilduppladdning och användarautentisering.

Först skapar vi en enkel bilduppladdnings-API. Genom att använda FastAPI kan vi enkelt skapa slutpunkter för att hantera bildfiler och metadata, till exempel bilmodeller, årsmodeller och priser. Ett exempel på en POST-begäran för att lägga till en bil kan se ut så här:

python
Copy code
async def add_car(request: Request):
    # Ladda upp bilens data
    car_data = request.json()  # Hämta data från JSON-begäran
    car = CarModel(**car_data)
    await cars.insert_one(car.dict())
    return {"message": "Car added successfully"}

För att börja med autentisering, skapar vi en AuthHandler-klass. Denna klass ansvarar för att hantera användarnas lösenordshantering och skapa JWT-tokens. Här implementeras en säker metod för att kryptera lösenord och skapa tokens som används för att validera användare vid varje begäran:

python
Copy code
class AuthHandler:

    security = HTTPBearer()
    pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
    secret = "FARMSTACKsecretString"
    def get_password_hash(self, password: str) -> str:
        return self.pwd_context.hash(password)

    def verify_password(self, plain_password: str, hashed_password: str) -> bool:

        return self.pwd_context.verify(plain_password, hashed_password)
    def encode_token(self, user_id: str, username: str) -> str:
        payload = {
            "exp": datetime.datetime.utcnow() + datetime.timedelta(minutes=30),
            "iat": datetime.datetime.utcnow(),
            "sub": {"user_id": user_id, "username": username}
        }
        return jwt.encode(payload, self.secret, algorithm="HS256")

    def decode_token(self, token: str) -> dict:

        try:
            payload = jwt.decode(token, self.secret, algorithms=["HS256"])
            return payload["sub"]
        except jwt.ExpiredSignatureError:
            raise HTTPException(status_code=401, detail="Signature has expired")
        except jwt.InvalidTokenError:
            raise HTTPException(status_code=401, detail="Invalid token")

Här kodas användartokens som innehåller information om användarens ID och användarnamn. Detta token används för att autentisera varje begäran. För att säkerställa att endast autentiserade användare kan skapa eller modifiera bilar, måste varje API-endpoint som hanterar resurser skyddas med en autentiseringstoken.

python
Copy code
@router.post("/register", response_description="Register user")

async def register(request: Request, new_user: LoginModel = Body(...)):

    users = request.app.db["users"]
    new_user.password = auth_handler.get_password_hash(new_user.password)
    existing_user = await users.find_one({"username": new_user["username"]})
    if existing_user:
        raise HTTPException(status_code=409, detail="Username already exists")
    await users.insert_one(new_user.dict())
    return {"message": "User registered successfully"}

Denna metod gör följande:

1. Krypterar användarens lösenord.

2. Kontrollerar om användarnamnet redan finns i databasen.

3. Registrerar användaren om användarnamnet är unikt.

När användaren är registrerad kan de logga in genom att använda sitt användarnamn och lösenord för att få ett JWT-token, vilket möjliggör autentisering i senare begärningar. JWT-tokenet kommer att användas som en autentisering för alla skyddade endpoints.

För att testa API:t lokalt kan du använda interaktiv dokumentation som FastAPI genererar. Genom att besöka 127.0.0.1:8000/docs kan användare testa att ladda upp bilder och skapa bilresurser via webgränssnittet. För att lägga till en bil med en bild via HTTPie kan du köra:

bash
Copy code
http --form POST 127.0.0.1:8000/cars brand="Ford" make="Focus" year=2000 cm3=1500 price=12000 km=23000 picture="ford.jpg"

Det är också viktigt att ha i åtanke att denna typ av API kräver noggrann hantering av användarbehörigheter och säkerhet. Om en angripare kan få tillgång till API:t utan autentisering kan systemet snabbt utnyttjas för att till exempel lägga upp stora mängder oönskad data eller bilder. Därför bör alltid autentisering och auktorisation implementeras innan API:t görs tillgängligt på en offentlig server.