"""Choosing what a spool label shows, and PNG output (#2981). Text is checked in the content stream of an uncompressed PDF, where ReportLab writes each string as it was drawn. """ from __future__ import annotations import io import re from datetime import date from unittest.mock import patch import pytest from PIL import Image from reportlab.lib.units import mm from reportlab.pdfgen import canvas as rl_canvas from backend.app.services.label_renderer import ( ALL_LABEL_FIELDS, DEFAULT_LABEL_FIELDS, LabelData, _breaks_before, _draw_label, label_size_mm, pdf_to_pngs, render_label_preview_pdf, render_labels, ) ALL = frozenset(ALL_LABEL_FIELDS) def _data(**overrides) -> LabelData: values = { "spool_id": 128, "name": "Jade White", "material": "PLA", "brand": "Bambu Lab", "subtype": "Matte", "rgba": "E8F0E0FF", "storage_location": "Shelf 2", "deeplink_url": "https://example.test/inventory?spool=128", "material_number": "MN-15", "nozzle_temp_min": 190, "nozzle_temp_max": 230, "label_weight": 1000, "note": "Dry first", "added": date(2026, 9, 30), } values.update(overrides) return LabelData(**values) def _text(template: str, data: LabelData, fields=DEFAULT_LABEL_FIELDS) -> bytes: """The page's content stream, i.e. only the text and shapes drawn. Not the whole file: its creation timestamp, document ID and xref offsets change from run to run, so a "not in" check against them fails whenever they happen to contain the digits (a run at 14:32:30 writes ``143230``). The QR code's image stream is left out for the same reason. """ w_mm, h_mm = label_size_mm(template) buf = io.BytesIO() c = rl_canvas.Canvas(buf, pagesize=(w_mm * mm, h_mm * mm), pageCompression=0) _draw_label(c, 0, 0, w_mm * mm, h_mm * mm, data, False, fields) c.showPage() c.save() pdf = buf.getvalue() # The page names its content stream; the embedded fonts and the QR image # are streams of their own. refs = re.findall(rb"/Contents (\d+) 0 R", pdf) assert len(refs) == 1, f"expected one page content stream, got {len(refs)}" m = re.search(rb"(?= id_y + 16 assert "2026-09-30" not in [text for _, text in drawn] def test_name_is_not_repeated_when_it_is_the_subtype(): """A Spoolman filament named after its colour gives subtype == name.""" pdf = _text("ams_holder_75x55", _data(name="Matte")) assert pdf.count(b"Matte") == 1 def test_name_prints_when_the_material_line_is_off(): pdf = _text("ams_holder_75x55", _data(name="Matte"), DEFAULT_LABEL_FIELDS - {"material"}) assert b"Matte" in pdf def test_tight_layout_honours_the_fields(): """The small layout only has brand, material, hex and ID; they obey the choice too.""" w, h = 40 * mm, 15 * mm buf = io.BytesIO() c = rl_canvas.Canvas(buf, pagesize=(w, h), pageCompression=0) _draw_label(c, 0, 0, w, h, _data(), False, frozenset({"hex"})) c.showPage() c.save() pdf = buf.getvalue() assert b"#E8F0E0" in pdf assert b"Bambu Lab" not in pdf assert b"#128" not in pdf def _assert_size(image: Image.Image, w_mm: float, h_mm: float, dpi: int) -> None: """PDFium rounds a fractional pixel up, so allow one either way.""" expected = (w_mm / 25.4 * dpi, h_mm / 25.4 * dpi) assert all(abs(got - want) <= 1 for got, want in zip(image.size, expected, strict=True)), (image.size, expected) @pytest.mark.parametrize( ("template", "size_mm"), [("box_40x30", (40.0, 30.0)), ("avery_l7160", (63.5, 38.1)), ("avery_5160", (66.675, 25.4))], ) def test_label_size_is_the_cell_for_a_sheet(template, size_mm): assert label_size_mm(template) == size_mm def test_preview_is_one_label_of_the_templates_size(): """A sheet's preview is one cell, not a whole A4 page.""" pngs = pdf_to_pngs(render_label_preview_pdf("avery_l7160", _data(), fields=ALL), 300) assert len(pngs) == 1 image = Image.open(io.BytesIO(pngs[0])) _assert_size(image, 63.5, 38.1, 300) @pytest.mark.parametrize("dpi", [203, 300, 600]) def test_png_is_printed_at_the_requested_resolution(dpi): pngs = pdf_to_pngs(render_labels("box_40x30", [_data()]), dpi) image = Image.open(io.BytesIO(pngs[0])) assert image.format == "PNG" _assert_size(image, 40, 30, dpi) assert tuple(round(v) for v in image.info["dpi"]) == (dpi, dpi) def test_one_png_per_page(): roll = pdf_to_pngs(render_labels("box_40x30", [_data(spool_id=i) for i in range(1, 4)]), 203) assert len(roll) == 3 sheets = pdf_to_pngs(render_labels("avery_l7160", [_data(spool_id=i) for i in range(1, 23)]), 72) assert len(sheets) == 2 def test_qr_stays_black_and_white_in_the_png(): """Rasterised without image smoothing, so the QR's modules keep hard edges instead of grey fringes a 203 dpi head can't print (#1870).""" png = pdf_to_pngs(render_label_preview_pdf("box_40x30", _data(), fields=frozenset({"qr"})), 203)[0] image = Image.open(io.BytesIO(png)).convert("L") # Only the QR is drawn besides the swatch and hairline border; crop to it. w, h = image.size qr_region = image.crop((w // 2, 0, w, h)) greys = sum(1 for v in qr_region.getdata() if 40 < v < 215) assert greys / (qr_region.width * qr_region.height) < 0.02 # ── Long rows continue on further lines (#3621) ────────────────────────────── ZH_NAME = "【快打】亚光PETG 哑光黑色 高速" def _lines( data: LabelData, fields=DEFAULT_LABEL_FIELDS, monochrome: bool = True, size_mm: tuple[int, int] = (40, 30) ) -> list[str]: """The text drawn on a label, 40 x 30 unless given, one entry per line, top to bottom. A line with Chinese is drawn in pieces, one per font, on one baseline.""" drawn: dict[float, str] = {} real = rl_canvas.Canvas.drawString def record(self, x, y, text, *args, **kwargs): drawn[round(y, 2)] = drawn.get(round(y, 2), "") + text return real(self, x, y, text, *args, **kwargs) w, h = size_mm[0] * mm, size_mm[1] * mm c = rl_canvas.Canvas(io.BytesIO(), pagesize=(w, h)) with patch.object(rl_canvas.Canvas, "drawString", record): _draw_label(c, 0, 0, w, h, data, monochrome, fields) return [drawn[y] for y in sorted(drawn, reverse=True)] def _name_lines(lines: list[str]) -> list[str]: """The lines between the hex code and the next row or the spool ID.""" start = lines.index("#E8F0E0") + 1 return [line for line in lines[start:] if line not in ("Shelf 2", "#128")] def test_a_long_chinese_name_continues_on_the_next_lines(): lines = _name_lines(_lines(_data(name=ZH_NAME, storage_location=None))) assert len(lines) > 1 # Nothing is lost but a space where a line breaks. assert "".join(lines).replace(" ", "") == ZH_NAME.replace(" ", "") assert not any(line.endswith("…") for line in lines) def test_a_latin_word_is_not_broken_next_to_chinese(): lines = _name_lines(_lines(_data(name=ZH_NAME, storage_location=None))) assert any(line.startswith("PETG") or line.endswith("PETG") for line in lines) assert not any(line.startswith("】") for line in lines) def test_a_long_latin_name_breaks_at_spaces(): name = "Matte Charcoal Black" lines = _name_lines(_lines(_data(name=name, storage_location=None))) assert len(lines) > 1 assert " ".join(lines) == name def test_the_row_below_keeps_its_line(): """The name takes no line the location needs: it is cut sooner instead.""" lines = _lines(_data(name=ZH_NAME, storage_location="Shelf 2")) assert "Shelf 2" in lines assert "#128" in lines assert _name_lines(lines)[-1].endswith("…") def test_a_row_takes_at_most_three_lines(): """Also on a label with room for more.""" lines = _name_lines(_lines(_data(name="Charcoal " * 30, storage_location=None), size_mm=(75, 55))) assert len(lines) == 3 assert lines[-1].endswith("…") def test_wrapped_lines_stay_above_the_spool_id(): drawn: list[tuple[float, str]] = [] real = rl_canvas.Canvas.drawString def record(self, x, y, text, *args, **kwargs): drawn.append((y, text)) return real(self, x, y, text, *args, **kwargs) with patch.object(rl_canvas.Canvas, "drawString", record): _text("box_40x30", _data(name="Charcoal " * 12, storage_location=None, note="Dry first " * 6), ALL) id_y = next(y for y, text in drawn if text == "#128") assert min(y for y, text in drawn if text != "#128") >= id_y + 16 def test_chinese_punctuation_stays_with_its_word(): """A line never starts with a closing bracket or comma, nor ends with an opening bracket.""" assert not _breaks_before("快打】", 2) assert not _breaks_before("快,打", 1) assert not _breaks_before("【快", 1) assert _breaks_before("快打", 1) assert _breaks_before("光PETG", 1) assert not _breaks_before("PETG", 1)