Behandeln Sie Umgebungsvariablen in Python elegant mit Pydantic

May 02 2023

Das Eintippen in Python ist keine Voraussetzung, kann aber bei der Verarbeitung von Eingaben aus verschiedenen Quellen eine echte Erleichterung sein. Umgebungsvariablen sind ein unverzichtbarer Ansatz zum Einfügen von Variablen in Programme, insbesondere in realen Bereitstellungen, da sie fast überall verwendet werden.

Bild erstellt von Jacob Ferus

Umgebungsvariablen in Python und Docker

In diesem Artikel habe ich die grundlegende Methode zum Zugriff auf Umgebungsvariablen mit dem os-module verwendet:

# get the environment variable MY_ENV_VARIABLE
# or return None if it doesn't exist
my_env_variable = os.getenv("MY_ENV_VARIABLE")

Betreten Sie Pydantic

Pydantic ist eine Python-Bibliothek, die die Datenvalidierung mithilfe von Typhinweisen in Python ermöglicht. Es wird üblicherweise zusammen mit dem Webframework FastAPI verwendet , wo es zur Validierung der Daten eingehender Anfragen verwendet wird. Darüber hinaus kann es auch in anderen Situationen verwendet werden, eine davon werden wir hier untersuchen (z. B. Umgebungsvariablen).

Wenn Sie bereits Typhinweise verwendet haben, wird Ihnen der Einstieg in Pydantic leicht fallen. Beginnen wir mit der Installation der Bibliothek:

pip install pydantic

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class SomeData(BaseModel):
    name: str
    age: int

@app.post("/data/")
async def post_data(data: SomeData):
    print(data)
    print(data.dict())

Dieser Webserver wird mit gestartet uvicorn main:app(vorausgesetzt, der Dateiname lautet main.py). Senden wir einige Anfragen, um zu sehen, wie Pydantic funktioniert:

import requests

requests.post("http://localhost:8000/data/", json={"name": "John", "age": 42})
# => SERVER OUTPUT:
# name='John' age=42
# {'name': 'John', 'age': 42}
requests.post("http://localhost:8000/data/", json={"name": 5, "age": "42"})
# => SERVER OUTPUT:
# name='5' age=42
# {'name': '5', 'age': 42}
requests.post("http://localhost:8000/data/", json={"name": "John", "age": { "foo": "bar"}})
# => SERVER ERROR: 
# HTTP Status 422 Unprocessable Entity

In der zweiten Anfrage haben die Werte nicht die richtigen Typen, sondern werden stattdessen in das richtige Format konvertiert, d. h. int -> strund str -> int. Wenn dieses Verhalten unerwünscht ist, besteht die Möglichkeit, strikte Typen zu verwenden .

Schließlich sind die Daten in der letzten Anfrage nicht verarbeitbar (JSON-Objekt kann nicht in int konvertiert werden) und der HTTP-Status 422, nicht verarbeitbare Entität, wird zurückgegeben.

Wenn wir von FastAPI ausgehen, können wir die gleiche Funktionalität bei der Verwaltung von Umgebungsvariablen verwenden. In diesem Fall wird statt BaseModel, BaseSettingsverwendet.

Hier lade ich Variablen aus einer .envDatei. Weitere Informationen zu dieser Datei finden Sie in meinem vorherigen Artikel . Die Datei enthält Folgendes:

NAME = "John"
AGE = 42

pip install python-dotenv

from pydantic import BaseSettings

class Envs(BaseSettings):
    name: str
    age: int

    class Config:
        env_file = '.env'

envs = Envs()

print(envs)
# => name='John' age=42

from pydantic import BaseSettings

class Envs(BaseSettings):
    name: str
    age: int

envs = Envs(_env_file='.env')

print(envs)
# => name='John' age=42

...
    class Config:
        case_sensitive = True

Komplexe Typen

Erstellen wir eine neue .env-Datei ( .env2):

my_array = '["hi", "how", "are", "you?"]'
my_object = '{"some_key": "some_value", "another_key": ["a", "b", "c"]}'
nested = '{"a": "a", "b": 1}'

from pydantic import BaseSettings, BaseModel
from typing import List

class NestedEnvs(BaseModel):
    a: str
    b: int

class Envs(BaseSettings):
    my_array: List[str]
    my_object: dict
    nested: NestedEnvs

envs = Envs(_env_file='.env2')

print(envs)
# => my_array=['hi', 'how', 'are', 'you?'] my_object={'some_key': 'some_value', 'another_key': ['a', 'b', 'c']} nested=NestedEnvs(a='a', b=1)

Komplexe Datentypen werden als JSON interpretiert. Daher sollten Sie das JSON-Objekt in einfache Anführungszeichen setzen und dann doppelte Anführungszeichen für Werte und Schlüssel innerhalb des JSON-Objekts verwenden. Folglich wird dies nicht funktionieren:

my_array = "['hi', 'how', 'are', 'you?']"

class Envs(BaseSettings):
...
    class Config:
        env_nested_delimiter = '__'

Als nächstes erweitern Sie die .envDatei:

my_array = '["hi", "how", "are", "you?"]'
my_object = '{"some_key": "some_value", "another_key": ["a", "b", "c"]}'
my_object__some_other_property = 'some_other_value'
nested = '{"a": "a", "b": 1}'

...
my_object={'some_key': 'some_value', 'another_key': ['a', 'b', 'c'], 'some_other_property': 'some_other_value'}
...

Standardwerte

Wenn eine Umgebungsvariable fehlt, ist es einfach, einen Standardwert hinzuzufügen:

from pydantic import BaseSettings

class Envs(BaseSettings):
    some_property: str = "default value"

envs = Envs()

print(envs)
# => some_property='default value'

Genau wie bei der Klasse können Sie Werte mithilfe der Methode und des Dekorators BaseModelvalidieren und nachbearbeiten . Nehmen wir ein Beispiel:Field()@validator

from pydantic import BaseSettings, Field, validator

class Envs(BaseSettings):
    between_0_and_10: int = Field(..., ge=0, le=10)
    prime: int

    @validator('prime')
    def is_prime(cls, n: int) -> int:
        if n <= 1:
            raise ValueError("Prime numbers must be greater than 1")
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                raise ValueError(f"{n} is not a prime number.")
        return n

envs = Envs(_env_file='.env3')

print(envs)

Abschluss

Obwohl Umgebungsvariablen ursprünglich als Zeichenfolgen gespeichert werden, ist es häufig wünschenswert, sie in spezifische oder komplexere Datentypen umzuwandeln. Pydantic bietet eine nahtlose Möglichkeit, genau das zu tun, was zu einem präzisen und standardisierten Ansatz für die Verwaltung von Umgebungsvariablen führt. Pydantic hat noch viel mehr zu bieten, als hier behandelt wurde, und ich empfehle Ihnen, die offizielle Dokumentation zu lesen , um mehr zu erfahren.