Barcode-Etikettenerzeugung mit Python: Eine Schritt-für-Schritt-Anleitung

Wenn Sie schon einmal versucht haben, ein Barcode-Etikett aus einem Python-Skript zu erzeugen, kennen Sie den üblichen Weg: eine Barcode-Bibliothek auswählen, ein Bild rendern, das Etikettenlayout selbst erstellen und dann herausfinden, wie man mit einem Thermodrucker kommuniziert. Dieser Leitfaden verfolgt einen anderen, verwalteten Ansatz. Sie verwenden das Next Generation Label Printing System (LPSNG) als Rendering- und Druck-Engine und steuern es aus Python mit einfachen HTTP-Anfragen.

Am Ende haben Sie ein Python-Skript, das:

• Sich bei der LPSNG-Webservice-API authentifiziert
• Ein Etikettenlayout nachschlägt
• Dynamische Artikeldaten einschließlich Barcode-Inhalt sendet
• Python-basierte Feldanpassungen anwendet
• Das Etikett als PDF oder PNG rendert
• Es an einen Drucker sendet oder lokal speichert

Dies ist ideal für Entwickler, die eine datengesteuerte Etikettenerzeugung in Lager-, Logistik-, Einzelhandels- oder Fulfillment-Workflows benötigen – ohne eine eigene Etiketten-Rendering-Pipeline aufbauen und warten zu müssen.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• Python 3.x auf Ihrem Rechner installiert.
• Ein LPSNG-Konto – entweder die Cloud-Edition oder eine Embedded-Edition – mit Zugriff auf die Webservice-API.
• Ein Etikettenlayout, das im LPSNG Label Studio erstellt wurde, oder ein Beispiel-Layout, das Sie zum Testen verwenden können. Das Layout sollte mindestens ein Barcode-Feld enthalten.
• OAuth2-Client-Anmeldedaten für die API-Authentifizierung. Siehe den OAuth2-Leitfaden für den vereinfachten Registrierungsablauf.
• Grundlegende Vertrautheit mit Python und REST-APIs. Der LPSNG-Webservice ist RESTful und gibt JSON zurück, sodass Standard-HTTP-Kenntnisse ausreichen.

Sie müssen keine Barcode-Schriftarten, ZPL/EPL-Treiber oder druckerspezifische SDKs installieren. LPSNG übernimmt diese Details hinter seinem Webservice.

Schritt für Schritt: Barcode-Etiketten mit Python erzeugen

Der Arbeitsablauf ist unkompliziert: authentifizieren, das Layout identifizieren, die Daten vorbereiten, optional Felder mit einem Python-Skriptblock anpassen, das Etikett rendern und drucken oder speichern.

Schritt 1: Richten Sie Ihre Python-Umgebung ein

Erstellen Sie ein Projektverzeichnis und installieren Sie die Bibliothek requests. Die LPSNG-API ist RESTful, daher benötigen Sie nur einen Standard-HTTP-Client.

mkdir lpsng-python-labeling
cd lpsng-python-labeling
python -m venv venv
source venv/bin/activate  # oder venv\Scripts\activate unter Windows
pip install requests

Erstellen Sie eine Datei namens generate_label.py. Definieren Sie oben Ihre LPSNG-Basis-URL und Ihre Anmeldedaten. Ersetzen Sie die Platzhalterwerte durch Ihre tatsächlichen Instanzdaten.

import requests
import json
from pathlib import Path

# Ersetzen Sie dies durch die URL Ihrer LPSNG-Instanz, z. B. https://your-instance.lpsng.rsj.de
LPSNG_BASE_URL = "https://your-instance.lpsng.rsj.de"

# Ersetzen Sie dies durch die Anmeldedaten aus Ihrer OAuth2-Registrierung
CLIENT_ID = "your-client-id"
CLIENT_SECRET = "your-client-secret"

Schritt 2: OAuth2-Zugriffstoken beziehen

LPSNG verwendet ein vereinfachtes OAuth2-Registrierungsprotokoll. Sobald Ihre externe Anwendung registriert ist, tauschen Sie Ihre Client-Anmeldedaten gegen ein Zugriffstoken.

Das folgende Beispiel hält den Token-Endpunkt als Variable, damit Sie ihn auf die exakte URL aus der Webservice-API-Dokumentation für Ihre Instanz verweisen können.

def get_access_token():
    # Verwenden Sie den Token-Endpunkt aus dem LPSNG-OAuth2-Leitfaden.
    token_url = f"{LPSNG_BASE_URL}/oauth2/token"

    response = requests.post(
        token_url,
        data={
            "grant_type": "client_credentials",
            "client_id": CLIENT_ID,
            "client_secret": CLIENT_SECRET,
        },
        timeout=30,
    )
    response.raise_for_status()
    return response.json()["access_token"]

Im Produktivcode sollten Sie das Token zwischenspeichern und vor Ablauf erneuern. Für diese exemplarische Vorgehensweise können Sie jedes Mal ein neues Token anfordern.

Schritt 3: Ihre Etikettenlayout-ID abrufen

Jedes Etikettenlayout in LPSNG hat eine ID. Sie können sie aus der LPSNG-Weboberfläche kopieren, indem Sie die Layouteigenschaften öffnen, oder sie über die API abfragen.

Der Weg über die Weboberfläche ist für einen ersten Test am einfachsten. Öffnen Sie Ihr Etikettenlayout im Label Studio und kopieren Sie die Layout-ID aus der URL oder den Layouteinstellungen.

Wenn Sie die Layout-Suche aus Python automatisieren möchten, verwenden Sie dasselbe REST-Muster. Der genaue Endpunkt kann je nach Instanz variieren, tragen Sie ihn daher aus Ihrer API-Referenz ein:

def find_layout_id(token, layout_name):
    headers = {"Authorization": f"Bearer {token}"}

    # Ersetzen Sie /layouts durch den Listen-Endpunkt, der für Ihre Instanz dokumentiert ist.
    response = requests.get(
        f"{LPSNG_BASE_URL}/layouts",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()

    for layout in response.json():
        if layout.get("name") == layout_name:
            return layout["id"]

    raise ValueError(f"Layout nicht gefunden: {layout_name}")

Für ein schnelles Skript ist eine fest codierte Layout-ID in Ordnung:

LAYOUT_ID = "your-layout-id"

Schritt 4: Die Daten-Nutzdaten mit Barcode-Inhalt vorbereiten

Die Webservice-API übermittelt Druckaufträge und rendert einzelne Etiketten. Ihre Nutzdaten enthalten typischerweise eine Reihe von Feldwerten für das Layout, einschließlich des Werts, der im Barcode codiert werden soll.

Hier ist ein Beispiel für Nutzdaten eines Artikeletiketts mit einem Code-128-Barcode:

label_data = {
    "product_name": "Thermal Label Roll 100x150",
    "sku": "THR-100-150",
    "barcode": "4012345678901",
    "quantity": 12,
    "batch": "B20260831-04",
}

Die Feldnamen in Ihren Nutzdaten müssen mit den Feldnamen übereinstimmen, die Sie im LPSNG Label Studio definiert haben. Wenn Ihr Layout ein Barcode-Feld namens barcode hat, codiert LPSNG den Wert, den Sie für dieses Feld senden, in dem im Layout konfigurierten Barcode-Format.

Schritt 5: Felder mit der Python Field Script API anpassen

LPSNG enthält eine Python Field Script API, mit der Sie kleine Python-Skriptblöcke an Etikettenfelder anhängen können. Diese Skripte werden vor dem Drucken ausgeführt und können auf Feldwerte zugreifen oder sie ändern.

Angenommen, Ihre Lagerdaten enthalten manchmal Kleinbuchstaben-Barcodes oder nachgestellte Leerzeichen, und Sie möchten den Wert normalisieren, bevor er den Barcode erreicht. Hängen Sie im LPSNG Label Studio einen Skriptblock an das Barcode-Feld an, der so aussieht:

# An das Barcode-Feld im LPSNG Label Studio angehängt.
# Das Skript wird vor dem Drucken ausgeführt und kann auf den aktuellen Wert zugreifen.
if "barcode" in context:
    value = str(context["barcode"]).strip().upper()

Der genaue Einstiegspunkt und die verfügbaren Objekte sind in der Python-API-Referenz dokumentiert. Verwenden Sie diese Referenz, um die exakte Hook-Signatur für Ihre LPSNG-Version zu überprüfen. Der Kerngedanke ist, dass Python-Skripte auf Feldebene die Formatierungslogik nahe am Etikett halten, während Ihre externe Python-Anwendung sich auf Datenvorbereitung und API-Aufrufe konzentriert.

Schritt 6: Den Webservice-Endpunkt aufrufen, um das Etikett zu rendern

Rufen Sie nun LPSNG auf, um das Etikett als PDF oder PNG zu rendern. Die Webservice-API kann einzelne Etiketten rendern, sodass Sie keinen lokalen Renderer ausführen müssen.

def render_label(token, layout_id, data, output_format="pdf"):
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
    }

    # Verwenden Sie den Render-Endpunkt aus der LPSNG-Webservice-API-Dokumentation.
    render_url = f"{LPSNG_BASE_URL}/render"

    response = requests.post(
        render_url,
        headers=headers,
        json={
            "layout_id": layout_id,
            "data": data,
            "format": output_format,
        },
        timeout=60,
    )
    response.raise_for_status()
    return response.content

Für die PNG-Ausgabe übergeben Sie "png" als Format. Die API-Antwort enthält den binären Dateiinhalt, den Sie direkt speichern können.

token = get_access_token()
pdf_bytes = render_label(token, LAYOUT_ID, label_data, "pdf")

Path("label.pdf").write_bytes(pdf_bytes)
print("Etikett gerendert: label.pdf")

Schritt 7: Das erzeugte Etikett an einen Drucker senden oder lokal speichern

Wenn Ihre LPSNG-Instanz mit Druckern verbunden ist, können Sie über dieselbe Webservice-API einen Druckauftrag übermitteln, anstatt die Datei herunterzuladen. Die genaue Anfragestruktur ist in der Webservice-Schnittstelle dokumentiert.

Ein typischer Direktdruck-Aufruf folgt demselben REST-Muster:

def send_to_printer(token, layout_id, data, printer_name):
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
    }

    # Verwenden Sie den Druck-Endpunkt, der für Ihre LPSNG-Instanz dokumentiert ist.
    print_url = f"{LPSNG_BASE_URL}/print"

    response = requests.post(
        print_url,
        headers=headers,
        json={
            "layout_id": layout_id,
            "data": data,
            "printer": printer_name,
        },
        timeout=60,
    )
    response.raise_for_status()
    return response.json()

Ersetzen Sie "printer" durch den Druckernamen oder die Drucker-ID, die in Ihrer LPSNG-Umgebung konfiguriert ist. Wenn Sie die Datei lieber lokal behalten möchten, überspringen Sie diesen Schritt und verwenden Sie die PDF- oder PNG-Ausgabe aus Schritt 6.

Überprüfen Ihrer Etikettenausgabe

Gehen Sie nicht davon aus, dass der Barcode korrekt ist, nur weil sich die PDF- oder PNG-Datei ohne Fehler öffnen ließ. Führen Sie diese Prüfungen durch:

• Öffnen Sie die erzeugte Datei visuell. Bestätigen Sie, dass die Textfelder gefüllt sind, der Barcode sichtbar ist und das Layout Ihrem Label-Studio-Design entspricht.
• Scannen Sie den Barcode mit einer Scanner-App. Richten Sie einen Smartphone-Barcode-Scanner auf den gedruckten oder auf dem Bildschirm angezeigten Barcode. Überprüfen Sie, dass die codierten Daten mit dem Wert übereinstimmen, den Sie in den Nutzdaten gesendet haben.
• Überprüfen Sie Feldanpassungen. Wenn Sie ein Python-Feldskript hinzugefügt haben, das den Barcode-Wert in Großbuchstaben umwandelt oder kürzt, senden Sie Testdaten in Kleinbuchstaben oder mit Leerzeichen und bestätigen Sie, dass sich die Ausgabe wie erwartet geändert hat.
• Testen Sie mit mehreren Datensätzen. Führen Sie das Skript mit verschiedenen SKUs, Mengen und Barcode-Werten aus, um sicherzustellen, dass kein Feld fest codiert oder falsch ausgerichtet ist.

Wenn Ihre Ausgabe eine PDF ist, drucken Sie sie einmal auf dem Ziel-Thermodrucker, um Etikettenabmessungen und Druckdichte zu bestätigen.

Fehlerbehebung bei häufigen Problemen

Authentifizierungsfehler

Überprüfen Sie Ihre OAuth2-Client-Anmeldedaten und den Token-Endpunkt. Wenn das Token abgelaufen ist, fordern Sie ein neues an. Bestätigen Sie, dass der Client weiterhin in Ihrem LPSNG-Konto registriert ist und dass das Konto über API-Zugriff verfügt.

Etikettenlayout nicht gefunden

Überprüfen Sie die Layout-ID und die Benutzerberechtigungen, die mit Ihrem OAuth2-Client verknüpft sind. Der Client hat möglicherweise Zugriff auf die API, aber nicht auf das spezifische Layout. Überprüfen Sie den Layoutnamen genau, einschließlich Groß-/Kleinschreibung und Leerzeichen.

Barcode wird nicht gerendert

Stellen Sie sicher, dass das Barcode-Format von LPSNG unterstützt wird und dass der Wert im Barcode-Feld für dieses Format gültig ist. Beispielsweise sollte ein Code-128-Feld Daten erhalten, die für Code 128 gültig sind. Siehe die Barcode-Formate-Dokumentation für die vollständige Liste der unterstützten 1D- und 2D-Formate.

Überprüfen Sie außerdem, dass das Barcode-Feld in Ihrem Layout tatsächlich dem Nutzdaten-Schlüssel zugeordnet ist, den Sie senden. Eine Nichtübereinstimmung zwischen Feldnamen ist eine häufige Ursache für leere Barcodes.

Feldskript-Fehler

Wenn Ihr Python-Feldskript einen Fehler auslöst, enthält die API-Antwort normalerweise eine Fehlermeldung. Lesen Sie sie sorgfältig; sie weist oft auf die Zeilennummer oder den Ausnahmetyp im Skriptblock hin. Verwenden Sie die Python-API-Referenz, um zu bestätigen, welche Objekte im Skriptkontext verfügbar sind.

Druckprobleme

Wenn das Etikett gerendert, aber nicht gedruckt wird, bestätigen Sie die Druckerkonnektivität und die Treibereinrichtung in Ihrer LPSNG-Umgebung. Überprüfen Sie, dass der Druckername in Ihrem Druckaufruf mit dem in LPSNG konfigurierten Namen übereinstimmt und dass der Drucker online ist.

FAQ

Kann ich Barcode-Etiketten in Python erzeugen, ohne den LPSNG-Webservice zu verwenden?

Ja, Sie könnten rohe Bibliotheken wie python-barcode oder reportlab verwenden, müssten sich dann aber selbst um Etikettendesign, Druckerkommunikation und Barcode-Standards kümmern. LPSNG bietet einen verwalteten Dienst mit einer Python-API, die den gesamten Prozess vereinfacht, einschließlich Feldanpassung und Direktdruck.

Welche Barcode-Formate werden von LPSNG unterstützt?

LPSNG unterstützt eine breite Palette von 1D- und 2D-Barcode-Formaten. Siehe die Barcode-Formate-Dokumentation für die vollständige Liste, einschließlich Code 128, QR-Code, Data Matrix und mehr.

Muss ich spezielle Python-Pakete installieren, um die LPSNG-API zu verwenden?

Es werden nur Standard-HTTP-Client-Bibliotheken wie requests benötigt. Die API ist RESTful und gibt JSON-Antworten zurück, was die Integration in jede Python-Umgebung erleichtert.

Kann ich die Python-API auch verwenden, um elektronische Regaletiketten (ESL) zu aktualisieren?

Ja, LPSNG bietet eine ESL-Schnittstelle und eine Binding-API, auf die über Python zugegriffen werden kann. Siehe die ESL-Dokumentation für Details zur programmatischen Aktualisierung von ESL-Anzeigen.

Fazit

Die Barcode-Etikettenerzeugung mit Python wird deutlich einfacher, wenn Sie einen verwalteten Dienst das Rendering, die Barcode-Standards und die Druckdetails übernehmen lassen. Mit LPSNG muss Ihre Python-Anwendung nur authentifizieren, Felddaten senden und einen REST-Endpunkt aufrufen. Das Etikettendesign bleibt im Label Studio, während Python-Feldskripte die Formatierung auf Feldebene übernehmen.

Dieser Ansatz fügt sich nahtlos in größere Automatisierungsworkflows ein. Wenn Sie als Entwickler Etikettensoftware evaluieren, lesen Sie Beste Etikettendesign-Software für Entwickler: Warum LPSNG heraussticht. Wenn sich Ihr Etikettierungsprojekt auf elektronische Regaletiketten erstreckt, fahren Sie fort mit ESL-Integration für den Einzelhandel: Ein vollständiger Leitfaden. Und wenn die meisten Ihrer Quelldaten in Tabellenkalkulationen liegen, verpassen Sie nicht Etikettendruck aus Excel automatisieren: Zeit sparen und Fehler reduzieren.

Bereit, Ihr erstes Python-generiertes Barcode-Etikett zu erstellen? Holen Sie sich Ihre OAuth2-Anmeldedaten, wählen Sie ein Layout und führen Sie das Skript mit einem echten Artikel aus. Das Next Generation Label Printing System übernimmt die Schwerstarbeit – Sie schreiben die Integration.

Verwandte Beiträge

• Beste Etikettendesign-Software für Entwickler: Warum LPSNG heraussticht
• ESL-Integration für den Einzelhandel: Ein vollständiger Leitfaden
• Etikettendruck aus Excel automatisieren: Zeit sparen und Fehler reduzieren