Bild aus einem Skript
Ein Python-Skript, das ein Diagramm zeichnet, damit das vorige Bild in einer Playlist ersetzt und veröffentlicht. Cron startet es alle fünf Minuten. Die Blöcke auf dieser Seite ergeben zusammen eine Datei.
1 Hol dir ein Token
Öffne das CMS unter Einstellungen, Verbundene Apps und klick auf Token generieren. Ein Mitglied ohne Administratorrechte sieht diesen Tab nicht.
Wähl danach die Organisation, die festlegt, welche Bildschirme das Programm sieht, und klick auf Zulassen. Die nächste Seite zeigt die Client-ID und das Refresh-Token, nur einmal. Kopiere beides.
Setz im Terminal die Client-ID und den Pfad der Token-Datei, und schreib das Refresh-Token in diese Datei. read -rs wartet, ohne etwas anzuzeigen: Füge das Refresh-Token ein und drück Enter, so bleibt es aus der Shell-History:
export GIBEON_CLIENT_ID=CLIENT_ID export GIBEON_REFRESH_TOKEN_FILE=./gibeon-refresh-token touch "$GIBEON_REFRESH_TOKEN_FILE" chmod 600 "$GIBEON_REFRESH_TOKEN_FILE" read -rs GIBEON_REFRESH_TOKEN && printf '%s' "$GIBEON_REFRESH_TOKEN" > "$GIBEON_REFRESH_TOKEN_FILE"
Installier die beiden Abhängigkeiten in einem venv, denn Homebrew-Python und Debian 12 oder neuer lehnen ein pip install außerhalb davon ab:
python3 -m venv .venv source .venv/bin/activate python3 -m pip install requests matplotlib
Leg die Blöcke unten der Reihe nach in gibeon.py ab und starte python3 gibeon.py.
2 Wähl die Playlist und den Bildschirm
Das Skript braucht zwei IDs. Die ID der Playlist steht in der Adressleiste des CMS, wenn du eine Playlist öffnest: /playlists/PLAYLIST_ID/content. Die ID des Bildschirms steht dort, wenn du einen Bildschirm öffnest: /devices/PLAYER_ID.
export GIBEON_PLAYLIST_ID=PLAYLIST_ID export GIBEON_PLAYER_ID=PLAYER_ID
Die Playlist muss schon auf dem Bildschirm liegen: Dieses Skript weist sie nicht zu. Das machst du einmal mit dem letzten Schritt des Schnellstarts für Python, Node.js oder Go, verlinkt am Ende dieser Seite.
Die Playlist gehört nur diesem Skript: Jeder Lauf entfernt jedes ältere Element, egal welches. Nimm also eine separate Playlist. Leg die Playlist nur auf diesen einen Bildschirm: Das Skript veröffentlicht nur diesen Bildschirm, und ein anderer Bildschirm mit derselben Playlist behielte ein Bild, das das Skript danach löscht.
3 Erneuere das Token
Ein Access-Token gilt 60 Minuten. Jede Erneuerung liefert auch ein neues Refresh-Token, ein Wert in der Umgebung ist also nach einem Lauf veraltet.
Das Programm schreibt das neue Token in eine temporäre Datei im selben Verzeichnis, setzt chmod 600 und benennt sie über die Datei in GIBEON_REFRESH_TOKEN_FILE um. Erst danach nutzt es das Access-Token. Ein Prozess, der dabei abbricht, behält so ein gültiges Refresh-Token.
Jede Anfrage prüft den Status: Bei einem Fehler beendet raise_for_status das Programm mit einem Exit-Code ungleich null.
import os
import tempfile
import requests
token_file = os.environ["GIBEON_REFRESH_TOKEN_FILE"]
with open(token_file) as f:
refresh_token = f.read().strip()
response = requests.post(
"https://id.gibeon.io/auth/v1/oauth/token",
data={
"grant_type": "refresh_token",
"client_id": os.environ["GIBEON_CLIENT_ID"],
"refresh_token": refresh_token,
},
timeout=30,
)
response.raise_for_status()
tokens = response.json()
# Store the new refresh token before anything uses the access token.
fd, tmp_path = tempfile.mkstemp(dir=os.path.dirname(token_file) or ".")
with os.fdopen(fd, "w") as f:
f.write(tokens["refresh_token"])
os.chmod(tmp_path, 0o600)
os.replace(tmp_path, token_file)
headers = {"Authorization": f"Bearer {tokens['access_token']}"} 4 Prüf den Bildschirm und lies die Playlist
Das Skript liest die beiden IDs, ruft den Bildschirm ab und liest die Elemente der Playlist, bevor es ein Asset anlegt. Ist eine ID veraltet, stoppt es hier und es kommt kein Bild dazu.
# Both are required: a missing one stops the run before it changes anything.
playlist_id = os.environ["GIBEON_PLAYLIST_ID"]
player_id = os.environ["GIBEON_PLAYER_ID"]
# A stale screen id stops the run here, before an asset exists.
response = requests.get(
f"https://www.gibeon.io/v1/players/{player_id}",
headers=headers,
timeout=30,
)
response.raise_for_status()
# Read before adding, so this list holds only the older items.
response = requests.get(
f"https://www.gibeon.io/v1/playlists/{playlist_id}/items",
headers=headers,
timeout=30,
)
response.raise_for_status()
older_items = response.json()["data"] 5 Zeichne das Diagramm
Dieser Block zeichnet feste Beispielzahlen in 1920 mal 1080 Pixeln. Ersetze sie durch deine. Figure braucht kein Display, das läuft also auch unter cron. Ein Bildschirm zeigt das Bild in der hochgeladenen Größe, zeichne es also in Bildschirmgröße, wie dieses Skript in 1920 mal 1080.
Jedes PNG funktioniert, auch das aus dem Grafana Image Renderer.
from datetime import datetime
from matplotlib.figure import Figure
figure = Figure(figsize=(16, 9), dpi=120)
axes = figure.subplots()
axes.bar(["North", "East", "South", "West"], [12, 19, 7, 15])
axes.set_title(datetime.now().strftime("Updated at %H:%M"))
figure.savefig("chart.png") 6 Lade das Bild hoch
Ein Upload hat zwei Schritte. POST /v1/assets legt das Asset an, danach sendet der PUT die Bytes mit Content-Type: image/png. Die file_size darf höchstens 10 Prozent von den gesendeten Bytes abweichen.
with open("chart.png", "rb") as f:
png = f.read()
response = requests.post(
"https://www.gibeon.io/v1/assets",
headers=headers,
json={
"name": "chart.png",
"asset_type": "image",
"mime_type": "image/png",
"file_size": len(png),
},
timeout=30,
)
response.raise_for_status()
asset_id = response.json()["data"]["id"]
response = requests.put(
f"https://www.gibeon.io/v1/assets/{asset_id}/upload",
headers={**headers, "Content-Type": "image/png"},
data=png,
timeout=60,
)
response.raise_for_status() 7 Ersetze das Element in der Playlist
Das Skript nutzt die Elemente, die es im Prüfschritt gelesen hat, diese Liste enthält also nur ältere Elemente. Es fügt das neue Element hinzu und löscht danach die älteren. So ist die Playlist nie leer.
response = requests.post(
f"https://www.gibeon.io/v1/playlists/{playlist_id}/items",
headers=headers,
json={"type": "image", "asset_id": asset_id, "duration_seconds": 30},
timeout=30,
)
response.raise_for_status()
for item in older_items:
item_id = item["id"]
response = requests.delete(
f"https://www.gibeon.io/v1/playlists/{playlist_id}/items/{item_id}",
headers=headers,
timeout=30,
)
response.raise_for_status() 8 Veröffentliche
Bis du veröffentlichst, zeigt der Bildschirm das vorige Bild. Das Veröffentlichen baut einen neuen Snapshot und benachrichtigt den Bildschirm sofort.
response = requests.post(
f"https://www.gibeon.io/v1/players/{player_id}/publish",
headers=headers,
timeout=30,
)
response.raise_for_status() 9 Entferne die älteren Bilder
Das Skript löscht nur die Assets der Elemente, die es gerade entfernt hat. Das passiert nach dem Veröffentlichen, denn der vorige Snapshot nutzte sie noch. Die API antwortet mit 409, solange ein anderes Element ein Asset nutzt: Das Skript akzeptiert das und lässt dieses Asset stehen. Jeder andere Fehler stoppt es. Zuletzt gibt es die ID des neuen Assets aus.
# A YouTube item has no asset_id, and two items can share an asset.
older_asset_ids = {item["asset_id"] for item in older_items if item["asset_id"]}
for older_asset_id in older_asset_ids:
response = requests.delete(
f"https://www.gibeon.io/v1/assets/{older_asset_id}",
headers=headers,
timeout=30,
)
# A 409 means another item still uses the asset, so it stays.
if response.status_code != 409:
response.raise_for_status()
print(asset_id) 10 Starte es alle fünf Minuten
Cron liest dein Terminal nicht, die Variablen stehen also in der crontab. Ersetze /PATH/TO/PROJECT durch das Verzeichnis mit gibeon.py, .venv und der Token-Datei:
GIBEON_CLIENT_ID=CLIENT_ID GIBEON_REFRESH_TOKEN_FILE=./gibeon-refresh-token GIBEON_PLAYLIST_ID=PLAYLIST_ID GIBEON_PLAYER_ID=PLAYER_ID */5 * * * * cd /PATH/TO/PROJECT && flock -n gibeon.lock .venv/bin/python gibeon.py >> gibeon.log 2>&1
flock -n überspringt einen Lauf, solange der vorige noch arbeitet, also können zwei Läufe sich nicht um die Token-Datei streiten. Die Sperre ist eine separate Datei, denn das Skript benennt die Token-Datei um.
Ein Access-Token läuft nach 60 Minuten ab. Jeder Lauf erneuert zuerst und speichert das neue Refresh-Token, also läuft das Skript über diese 60 Minuten hinaus weiter.
Die Ausgabe und die Fehler jedes Laufs landen in gibeon.log.