355 lines
13 KiB
Python
355 lines
13 KiB
Python
from __future__ import annotations
|
|
|
|
import base64
|
|
import io
|
|
import os
|
|
import re
|
|
import shlex
|
|
import subprocess
|
|
import uuid
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
from flask import Flask, jsonify, render_template, request, send_from_directory
|
|
from PIL import Image, ImageDraw, ImageFont, ImageOps
|
|
|
|
try:
|
|
import barcode
|
|
from barcode.writer import ImageWriter
|
|
except Exception: # pragma: no cover - optional at runtime until installed
|
|
barcode = None
|
|
ImageWriter = None
|
|
|
|
try:
|
|
import qrcode
|
|
except Exception: # pragma: no cover - optional at runtime until installed
|
|
qrcode = None
|
|
|
|
|
|
BASE_DIR = Path(__file__).resolve().parent.parent
|
|
LABEL_DIR = Path(os.environ.get("LABEL_DIR", BASE_DIR / "labels"))
|
|
LABEL_DIR.mkdir(parents=True, exist_ok=True)
|
|
|
|
DEFAULT_PRINT_COMMAND = "ptouch-print --image {image}"
|
|
PRINT_COMMAND = os.environ.get("PRINT_COMMAND", DEFAULT_PRINT_COMMAND)
|
|
PRINT_ENABLED = os.environ.get("PRINT_ENABLED", "1").lower() in {"1", "true", "yes", "on"}
|
|
DPI = int(os.environ.get("LABEL_DPI", "180"))
|
|
|
|
TAPE_WIDTHS_MM = [3.5, 6, 9, 12, 18, 24]
|
|
|
|
app = Flask(__name__)
|
|
app.secret_key = os.environ.get("SECRET_KEY", "change-me")
|
|
|
|
|
|
def mm_to_px(mm: float) -> int:
|
|
return max(1, round(mm / 25.4 * DPI))
|
|
|
|
|
|
def clamp(value: float, low: float, high: float) -> float:
|
|
return max(low, min(high, value))
|
|
|
|
|
|
def get_font(size_px: int, bold: bool = False) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
|
|
candidates = [
|
|
"/usr/share/fonts/dejavu/DejaVuSans-Bold.ttf" if bold else "/usr/share/fonts/dejavu/DejaVuSans.ttf",
|
|
"/usr/share/fonts/TTF/DejaVuSans-Bold.ttf" if bold else "/usr/share/fonts/TTF/DejaVuSans.ttf",
|
|
"/System/Library/Fonts/Supplemental/Arial Bold.ttf" if bold else "/System/Library/Fonts/Supplemental/Arial.ttf",
|
|
]
|
|
for path in candidates:
|
|
if Path(path).exists():
|
|
return ImageFont.truetype(path, size_px)
|
|
return ImageFont.load_default()
|
|
|
|
|
|
def new_label_image(width_px: int, height_px: int) -> Image.Image:
|
|
image = Image.new("P", (width_px, height_px), 0)
|
|
image.putpalette([255, 255, 255, 0, 0, 0] + [0, 0, 0] * 254)
|
|
return image
|
|
|
|
|
|
def object_box(obj: dict[str, Any]) -> tuple[int, int, int, int]:
|
|
x = mm_to_px(float(obj.get("x", 0)))
|
|
y = mm_to_px(float(obj.get("y", 0)))
|
|
w = mm_to_px(float(obj.get("w", 10)))
|
|
h = mm_to_px(float(obj.get("h", 5)))
|
|
return x, y, max(1, w), max(1, h)
|
|
|
|
|
|
def wrap_text(draw: ImageDraw.ImageDraw, text: str, font, max_width: int) -> list[str]:
|
|
lines: list[str] = []
|
|
for raw_line in text.splitlines() or [""]:
|
|
current = ""
|
|
for word in raw_line.split(" "):
|
|
candidate = word if not current else f"{current} {word}"
|
|
if draw.textbbox((0, 0), candidate, font=font)[2] <= max_width:
|
|
current = candidate
|
|
continue
|
|
if current:
|
|
lines.append(current)
|
|
current = word
|
|
if current:
|
|
lines.append(current)
|
|
return lines
|
|
|
|
|
|
def draw_text(draw: ImageDraw.ImageDraw, obj: dict[str, Any]) -> None:
|
|
x, y, w, h = object_box(obj)
|
|
text = str(obj.get("text", "Text"))
|
|
font_size = mm_to_px(float(obj.get("fontSizeMm", 5)))
|
|
font = get_font(font_size, bool(obj.get("bold", False)))
|
|
align = obj.get("align", "left")
|
|
valign = obj.get("valign", "middle")
|
|
lines = wrap_text(draw, text, font, w)
|
|
boxes = [draw.textbbox((0, 0), line, font=font) for line in lines]
|
|
line_heights = [box[3] - box[1] for box in boxes]
|
|
gap = max(1, round(font_size * 0.15))
|
|
total_h = sum(line_heights) + max(0, len(lines) - 1) * gap
|
|
if valign == "top":
|
|
cy = y
|
|
elif valign == "bottom":
|
|
cy = y + h - total_h
|
|
else:
|
|
cy = y + (h - total_h) // 2
|
|
for line, box, line_h in zip(lines, boxes, line_heights):
|
|
text_w = box[2] - box[0]
|
|
if align == "center":
|
|
cx = x + (w - text_w) // 2
|
|
elif align == "right":
|
|
cx = x + w - text_w
|
|
else:
|
|
cx = x
|
|
draw.text((cx, cy - box[1]), line, font=font, fill=1)
|
|
cy += line_h + gap
|
|
|
|
|
|
def draw_shape(draw: ImageDraw.ImageDraw, obj: dict[str, Any]) -> None:
|
|
x, y, w, h = object_box(obj)
|
|
line = max(1, mm_to_px(float(obj.get("lineMm", 0.25))))
|
|
shape = obj.get("shape", "rect")
|
|
fill = 1 if obj.get("fill", False) else None
|
|
box = [x, y, x + w, y + h]
|
|
if shape == "ellipse":
|
|
draw.ellipse(box, outline=1, fill=fill, width=line)
|
|
elif shape == "line":
|
|
draw.line((x, y, x + w, y + h), fill=1, width=line)
|
|
else:
|
|
draw.rectangle(box, outline=1, fill=fill, width=line)
|
|
|
|
|
|
def paste_mono(image: Image.Image, source: Image.Image, x: int, y: int, w: int, h: int) -> None:
|
|
source = ImageOps.grayscale(source).resize((w, h), Image.Resampling.LANCZOS)
|
|
mask = source.point(lambda p: 255 if p < 160 else 0, "1")
|
|
black = Image.new("P", (w, h), 1)
|
|
black.putpalette([255, 255, 255, 0, 0, 0] + [0, 0, 0] * 254)
|
|
image.paste(black, (x, y), mask)
|
|
|
|
|
|
def decode_data_image(data_url: str) -> Image.Image:
|
|
if "," in data_url:
|
|
data_url = data_url.split(",", 1)[1]
|
|
return Image.open(io.BytesIO(base64.b64decode(data_url)))
|
|
|
|
|
|
def draw_qr(image: Image.Image, obj: dict[str, Any]) -> None:
|
|
if qrcode is None:
|
|
raise RuntimeError("qrcode ist nicht installiert.")
|
|
x, y, w, h = object_box(obj)
|
|
qr = qrcode.QRCode(border=1, box_size=10)
|
|
qr.add_data(str(obj.get("text", "https://example.local")))
|
|
qr.make(fit=True)
|
|
qr_img = qr.make_image(fill_color="black", back_color="white").convert("RGB")
|
|
side = min(w, h)
|
|
paste_mono(image, qr_img, x, y, side, side)
|
|
|
|
|
|
def draw_barcode(image: Image.Image, obj: dict[str, Any]) -> None:
|
|
if barcode is None or ImageWriter is None:
|
|
raise RuntimeError("python-barcode ist nicht installiert.")
|
|
x, y, w, h = object_box(obj)
|
|
writer = ImageWriter()
|
|
code = barcode.get("code128", str(obj.get("text", "1234567890")), writer=writer)
|
|
buffer = io.BytesIO()
|
|
code.write(buffer, {"write_text": bool(obj.get("showText", True)), "quiet_zone": 1.0, "module_height": 8.0})
|
|
buffer.seek(0)
|
|
paste_mono(image, Image.open(buffer), x, y, w, h)
|
|
|
|
|
|
def draw_table(draw: ImageDraw.ImageDraw, obj: dict[str, Any]) -> None:
|
|
x, y, w, h = object_box(obj)
|
|
rows = max(1, int(obj.get("rows", 2)))
|
|
cols = max(1, int(obj.get("cols", 2)))
|
|
line = max(1, mm_to_px(float(obj.get("lineMm", 0.2))))
|
|
draw.rectangle([x, y, x + w, y + h], outline=1, width=line)
|
|
for col in range(1, cols):
|
|
cx = x + round(w * col / cols)
|
|
draw.line((cx, y, cx, y + h), fill=1, width=line)
|
|
for row in range(1, rows):
|
|
cy = y + round(h * row / rows)
|
|
draw.line((x, cy, x + w, cy), fill=1, width=line)
|
|
|
|
|
|
def render_design(design: dict[str, Any]) -> Path:
|
|
tape_width = float(design.get("tapeWidthMm", 24))
|
|
if tape_width not in TAPE_WIDTHS_MM:
|
|
raise ValueError("Ungueltige Bandbreite.")
|
|
length = clamp(float(design.get("lengthMm", 70)), 10, 500)
|
|
orientation = design.get("orientation", "landscape")
|
|
if orientation == "portrait":
|
|
canvas_w_mm, canvas_h_mm = tape_width, length
|
|
else:
|
|
canvas_w_mm, canvas_h_mm = length, tape_width
|
|
|
|
image = new_label_image(mm_to_px(canvas_w_mm), mm_to_px(canvas_h_mm))
|
|
draw = ImageDraw.Draw(image)
|
|
|
|
for obj in design.get("objects", []):
|
|
if not isinstance(obj, dict) or obj.get("hidden"):
|
|
continue
|
|
obj_type = obj.get("type")
|
|
if obj_type == "text" or obj_type == "symbol":
|
|
draw_text(draw, obj)
|
|
elif obj_type == "shape":
|
|
draw_shape(draw, obj)
|
|
elif obj_type == "line":
|
|
draw_shape(draw, {**obj, "shape": "line"})
|
|
elif obj_type == "table":
|
|
draw_table(draw, obj)
|
|
elif obj_type == "image" and obj.get("dataUrl"):
|
|
x, y, w, h = object_box(obj)
|
|
paste_mono(image, decode_data_image(str(obj["dataUrl"])), x, y, w, h)
|
|
elif obj_type == "qr":
|
|
draw_qr(image, obj)
|
|
elif obj_type == "barcode":
|
|
draw_barcode(image, obj)
|
|
|
|
output = LABEL_DIR / f"label-{uuid.uuid4().hex}.png"
|
|
image.save(output)
|
|
return output
|
|
|
|
|
|
def run_print_command(image_path: Path, copies: int) -> subprocess.CompletedProcess[str]:
|
|
command = PRINT_COMMAND.format(image=shlex.quote(str(image_path)), copies=copies)
|
|
return subprocess.run(shlex.split(command), capture_output=True, check=False, text=True, timeout=90)
|
|
|
|
|
|
def print_label(image_path: Path, copies: int) -> list[subprocess.CompletedProcess[str]]:
|
|
if "{copies}" in PRINT_COMMAND:
|
|
return [run_print_command(image_path, copies)]
|
|
return [run_print_command(image_path, 1) for _ in range(copies)]
|
|
|
|
|
|
def detect_tape_width() -> tuple[float | None, str]:
|
|
result = subprocess.run(
|
|
["ptouch-print", "--info"],
|
|
capture_output=True,
|
|
check=False,
|
|
text=True,
|
|
timeout=20,
|
|
)
|
|
output = "\n".join(part for part in [result.stdout.strip(), result.stderr.strip()] if part)
|
|
if result.returncode != 0:
|
|
raise RuntimeError(format_print_error(result))
|
|
|
|
candidates: list[float] = []
|
|
for pattern in [
|
|
r"(?:tape|media|band|width|breite|size|groesse|printing)[^\n:=-]*[:=-]?\s*(\d+(?:[.,]\d+)?)\s*mm",
|
|
r"(\d+(?:[.,]\d+)?)\s*mm",
|
|
]:
|
|
for match in re.finditer(pattern, output, re.IGNORECASE):
|
|
candidates.append(float(match.group(1).replace(",", ".")))
|
|
|
|
for supported in TAPE_WIDTHS_MM:
|
|
if any(abs(candidate - supported) < 0.26 for candidate in candidates):
|
|
return supported, output
|
|
return None, output
|
|
|
|
|
|
def format_print_error(result: subprocess.CompletedProcess[str]) -> str:
|
|
details = result.stderr.strip() or result.stdout.strip() or "Unbekannter Fehler"
|
|
if "PLite Mode" in details or "RemovableDisk" in details:
|
|
return (
|
|
"Drucker ist im Editor-Lite/PLite-Modus. Am PT-P700 die Editor-Lite-Taste deaktivieren, "
|
|
"bis die Editor-Lite-LED aus ist, USB neu verbinden und erneut drucken. "
|
|
f"Details: {details}"
|
|
)
|
|
if "LIBUSB_ERROR_IO" in details or "libusb_open error" in details:
|
|
return (
|
|
"Drucker wurde gefunden, konnte aber per libusb nicht geoeffnet werden. "
|
|
"In Unraid pruefen: Privileged an, /dev/bus/usb Read/Write gemountet, usblp nicht geladen. "
|
|
f"Details: {details}"
|
|
)
|
|
return f"Druck fehlgeschlagen: {details}"
|
|
|
|
|
|
def design_from_request() -> tuple[dict[str, Any], int]:
|
|
payload = request.get_json(force=True)
|
|
design = payload.get("design") if isinstance(payload, dict) else None
|
|
if not isinstance(design, dict):
|
|
raise ValueError("Kein gueltiges Layout erhalten.")
|
|
copies = int(payload.get("copies", 1))
|
|
return design, max(1, min(20, copies))
|
|
|
|
|
|
@app.get("/")
|
|
def index():
|
|
return render_template(
|
|
"index.html",
|
|
tape_widths=TAPE_WIDTHS_MM,
|
|
print_enabled=PRINT_ENABLED,
|
|
default_command=PRINT_COMMAND,
|
|
)
|
|
|
|
|
|
@app.get("/mobile")
|
|
def mobile():
|
|
return render_template(
|
|
"mobile.html",
|
|
tape_widths=TAPE_WIDTHS_MM,
|
|
print_enabled=PRINT_ENABLED,
|
|
default_command=PRINT_COMMAND,
|
|
)
|
|
|
|
|
|
@app.post("/api/preview")
|
|
def api_preview():
|
|
try:
|
|
design, _copies = design_from_request()
|
|
image_path = render_design(design)
|
|
return jsonify({"ok": True, "image": f"/labels/{image_path.name}"})
|
|
except Exception as exc:
|
|
return jsonify({"ok": False, "error": str(exc)}), 400
|
|
|
|
|
|
@app.post("/api/print")
|
|
def api_print():
|
|
try:
|
|
design, copies = design_from_request()
|
|
image_path = render_design(design)
|
|
if PRINT_ENABLED:
|
|
results = print_label(image_path, copies)
|
|
failed = next((result for result in results if result.returncode != 0), None)
|
|
if failed:
|
|
raise RuntimeError(format_print_error(failed))
|
|
message = "Etikett wurde an den Drucker gesendet."
|
|
else:
|
|
message = f"Testmodus: Etikett erstellt, nicht gedruckt: {image_path.name}"
|
|
return jsonify({"ok": True, "message": message, "image": f"/labels/{image_path.name}"})
|
|
except Exception as exc:
|
|
return jsonify({"ok": False, "error": str(exc)}), 400
|
|
|
|
|
|
@app.get("/api/tape-info")
|
|
def api_tape_info():
|
|
try:
|
|
width, raw = detect_tape_width()
|
|
if width is None:
|
|
return jsonify({"ok": False, "error": "Bandbreite konnte nicht erkannt werden.", "raw": raw}), 400
|
|
return jsonify({"ok": True, "width": width, "raw": raw})
|
|
except Exception as exc:
|
|
return jsonify({"ok": False, "error": str(exc)}), 400
|
|
|
|
|
|
@app.get("/labels/<path:filename>")
|
|
def labels(filename: str):
|
|
return send_from_directory(LABEL_DIR, filename)
|