build_template.py

skills/artwork-template-rebuilder/scripts/build_template.py

1. #!/usr/bin/env python3
2. """
3. build_template.py - Rebuild a vendor artwork template into the Meridian Display Co. house standard.
5. Produces a print-ready PDF with FOUR real Illustrator/Acrobat layers (OCGs):
6. Layout Area, Safe Line, Artwork Layer, Help Info
8. Geometry is driven by explicit dimensions (the calling agent extracts these from the
9. source template and passes them in). The script only renders; it does not guess.
11. Usage:
12. python build_template.py \
13. --sku BS20 --name "Quick-Set Step and Repeat Backdrop, Large (up to 10 x 20 ft)" \
14. --bleed-w 144 --bleed-h 120 \
15. --visual-w 138 --visual-h 114 \
16. --out /mnt/user-data/outputs/template.pdf
18. All dimensions are in INCHES. --visual-w/h is the red safe-line size (from
19. measure_template.py). If it is omitted, --safe-margin (a uniform inset in inches from
20. the bleed edge to the red safe line) is used instead; it defaults to 2.0in (a sane
21. backdrop default) - prefer passing the real measured value.
22. """
23. import argparse, sys
24. from reportlab.pdfgen import canvas
25. from reportlab.lib.colors import CMYKColor
26. from reportlab.pdfbase import pdfmetrics
27. from reportlab.pdfbase.ttfonts import TTFont
28. import pikepdf
30. # ---- House standard constants (extracted from confirmed-correct TD20 & BD08 templates) ----
31. PT = 72.0 # points per inch
32. BLACK = CMYKColor(0, 0, 0, 1)
33. RED = CMYKColor(0, 1, 1, 0) # final warning line + stitching/safety callouts
34. TEAL = CMYKColor(0.78, 0.45, 0.52, 0.05) # inline key-term accent (150dpi, CMYK, PMS, flatten, outline)
36. LAYERS = ["Layout Area", "Safe Line", "Artwork Layer", "Help Info"]
38. LIB = "/usr/share/fonts/truetype/liberation/"
39. FONT_REG, FONT_BOLD = "Arial", "Arial-Bold" # Liberation Sans = metric-identical Arial
41. # Canonical boilerplate. Each block is (kind, ...). Runs are (text, color, bold).
42. NOTES_BULLETS = [
43. [("- All graphic files must be built at ", BLACK, False), ("150dpi ", TEAL, False),
44. ("at the overall graphic layout size.", BLACK, False)],
45. [("- All graphic files must be created using ", BLACK, False), ("CMYK ", TEAL, False),
46. ("mode to ensure the best color matching. If you would like a specific color matched, you "
47. "MUST provide both ", BLACK, False), ("PMS ", TEAL, False), ("color and ", BLACK, False),
48. ("CMYK ", TEAL, False), ("values or we cannot guarantee color matching.", BLACK, False)],
49. [("- It is best to ", BLACK, False), ("flatten ", TEAL, False), ("all images and ", BLACK, False),
50. ("outline ", TEAL, False), ("all text to ensure that nothing will be dropped out or changed "
51. "during the file transfer.", BLACK, False)],
52. [("- Graphics can be extended to the very edge but beware of the red visual line. Keep "
53. "important images & text inside the red visual line. Images outside of the red visual line "
54. "are subject to be trimmed off or covered by stitching.", BLACK, False)],
55. [("- Remove the red visual line and help instructions upon submitting your artwork.", RED, False)],
56. ]
57. PREFERRED = [
58. [(" - .PDF (Vector Format or 100% Sized, Text Outlined, Images Embedded)", BLACK, False)],
59. [(" - .JPG / .JPEG (100% Sized, 150dpi)", BLACK, False)],
60. ]
61. ACCEPTED = [
62. [(" - .AI or .EPS (Text Outlined, Images Embedded)", BLACK, False)],
63. [(" - .PSD (100% Sized, 150dpi)", BLACK, False)],
64. ]
67. def register_fonts():
68. try:
69. pdfmetrics.registerFont(TTFont(FONT_REG, LIB + "LiberationSans-Regular.ttf"))
70. pdfmetrics.registerFont(TTFont(FONT_BOLD, LIB + "LiberationSans-Bold.ttf"))
71. return FONT_REG, FONT_BOLD
72. except Exception:
73. return "Helvetica", "Helvetica-Bold" # built-in Arial-metric fallback
76. def sw(text, font, size):
77. return pdfmetrics.stringWidth(text, font, size)
80. class Info:
81. """Top-down text engine on the canvas with colored runs, wrapping, bold + underline."""
82. def __init__(self, c, x, y, width, body, fonts):
83. self.c, self.x, self.y, self.width = c, x, y, width
84. self.body = body
85. self.reg, self.bold = fonts
86. self.lead = body * 1.32
88. def gap(self, mult=1.0):
89. self.y -= self.lead * mult
91. def heading(self, text, size=None, underline=True):
92. size = size or self.body * 1.12
93. self.c.setFillColor(BLACK)
94. self.c.setFont(self.bold, size)
95. self.c.drawString(self.x, self.y, text)
96. if underline:
97. w = sw(text, self.bold, size)
98. uy = self.y - size * 0.14
99. self.c.setStrokeColor(BLACK)
100. self.c.setLineWidth(max(1.0, size * 0.045))
101. self.c.line(self.x, uy, self.x + w, uy)
102. self.y -= self.lead * 1.15
104. def line_runs(self, runs, size=None, bold_all=False):
105. """Draw one logical paragraph of mixed-color runs, word-wrapped to width."""
106. size = size or self.body
107. lead = size * 1.32
108. font = self.bold if bold_all else self.reg
109. # tokenize into (word, color, bold) keeping spaces
110. tokens = []
111. for text, color, bold in runs:
112. parts = text.split(" ")
113. for i, p in enumerate(parts):
114. if p:
115. tokens.append([p, color, bold or bold_all])
116. if i < len(parts) - 1:
117. tokens.append([" ", color, bold or bold_all])
118. cx = self.x
119. for tok, color, bold in tokens:
120. f = self.bold if bold else self.reg
121. wdt = sw(tok, f, size)
122. if tok != " " and cx + wdt > self.x + self.width and cx > self.x:
123. self.y -= lead
124. cx = self.x
125. if tok == " ":
126. continue
127. self.c.setFillColor(color)
128. self.c.setFont(f, size)
129. self.c.drawString(cx, self.y, tok)
130. cx += wdt
131. self.y -= lead
133. def paras(self, blocks, size=None):
134. for runs in blocks:
135. self.line_runs(runs, size=size)
138. def begin_oc(c, name):
139. c.addLiteral(f"/OC /OC_{name.replace(' ', '_')} BDC")
142. def end_oc(c):
143. c.addLiteral("EMC")
146. def build(sku, name, bleed_w, bleed_h, visual_w, visual_h, safe_margin, out):
147. reg, bold = register_fonts()
148. fonts = (reg, bold)
150. bw, bh = bleed_w * PT, bleed_h * PT # artwork WITH bleed (solid black boundary)
151. pb = max(bw, bh) * 0.03 # pasteboard margin so the boundary is visible
152. PW, PH = bw + 2 * pb, bh + 2 * pb
153. c = canvas.Canvas(out, pagesize=(PW, PH))
154. c.setTitle(f"[{sku}] - {name}")
156. unit = bh / 100.0 # scale everything to artwork height
157. body = max(8.0, unit * 1.30)
159. # safe/visual insets (non-uniform supported): derive from visual size if given
160. if visual_w is not None and visual_h is not None:
161. sm_x = max(0.0, (bleed_w - visual_w) / 2.0) * PT
162. sm_y = max(0.0, (bleed_h - visual_h) / 2.0) * PT
163. else:
164. sm_x = sm_y = safe_margin * PT
165. visual_w = bleed_w - 2 * safe_margin
166. visual_h = bleed_h - 2 * safe_margin
168. # black boundary = artwork-with-bleed edge, inset from page by pasteboard
169. bx0, by0, bx1, by1 = pb, pb, pb + bw, pb + bh
170. # red dashed safe line, inset from the black boundary
171. sx0, sy0 = bx0 + sm_x, by0 + sm_y
172. sx1, sy1 = bx1 - sm_x, by1 - sm_y
174. # ---------------- Layer: Layout Area (solid black artwork-with-bleed boundary) ----------
175. begin_oc(c, "Layout Area")
176. c.setStrokeColor(BLACK)
177. c.setLineWidth(max(1.5, unit * 0.06))
178. c.rect(bx0, by0, bx1 - bx0, by1 - by0, stroke=1, fill=0)
179. end_oc(c)
181. # ---------------- Layer: Safe Line (red dashed) ----------------
182. begin_oc(c, "Safe Line")
183. c.setStrokeColor(RED)
184. c.setLineWidth(max(1.5, unit * 0.09))
185. dash = max(6.0, unit * 0.8)
186. c.setDash(dash, dash * 0.7)
187. c.rect(sx0, sy0, sx1 - sx0, sy1 - sy0, stroke=1, fill=0)
188. c.setDash()
189. end_oc(c)
191. # ---------------- Layer: Artwork Layer (intentionally empty) ----------------
192. begin_oc(c, "Artwork Layer")
193. c.addLiteral("") # real OCG, no marks - designer drops art here
194. end_oc(c)
196. # ---------------- Layer: Help Info (all text + legend) ----------------
197. begin_oc(c, "Help Info")
198. pad = unit * 1.4
199. safe_w = sx1 - sx0
200. col_w = max(safe_w * 0.46, unit * 30) # narrow column like the standard
201. col_w = min(col_w, safe_w - pad * 2)
202. ix = sx0 + pad
203. iy = sy1 - pad - unit * 2.0
204. info = Info(c, ix, iy, col_w, body, fonts)
206. # Title + subtitle
207. c.setFillColor(BLACK); c.setFont(bold, unit * 2.0)
208. c.drawString(ix, info.y, f"[{sku.upper()}] - {name}")
209. info.y -= info.lead * 1.5
210. c.setFillColor(BLACK); c.setFont(reg, unit * 1.30)
211. c.drawString(ix, info.y, "Artwork Template")
212. info.y -= info.lead * 1.6
214. # Spec block
215. info.heading("Graphic Size with Bleed:", size=unit * 1.35, underline=False)
216. info.line_runs([(f"{fmt(bleed_w)} W x {fmt(bleed_h)} H inches", BLACK, False)])
217. info.gap(0.5)
218. info.heading("Visual / Safe Area:", size=unit * 1.35, underline=False)
219. info.line_runs([(f"{fmt(visual_w)} W x {fmt(visual_h)} H inches", BLACK, False)])
220. info.gap(0.4)
221. info.line_runs([("Keep all critical content inside the red safe line.", BLACK, False)])
222. info.gap(0.8)
224. # Legend
225. _legend_row(c, info, "Bleed / Layout Edge", BLACK, dashed=False, unit=unit, body=body)
226. _legend_row(c, info, "Safe Visual Line", RED, dashed=True, unit=unit, body=body)
227. info.gap(1.0)
229. # Notes
230. info.heading("Notes to Designers:")
231. info.paras(NOTES_BULLETS)
232. info.gap(1.0)
234. info.heading("Preferred File Formats:")
235. info.paras(PREFERRED)
236. info.gap(0.8)
238. info.heading("Accepted File Formats:")
239. info.paras(ACCEPTED)
240. end_oc(c)
242. c.showPage()
243. c.save()
244. _inject_ocgs(out)
245. return out
248. def _legend_row(c, info, label, color, dashed, unit, body):
249. y = info.y
250. c.setFillColor(BLACK); c.setFont(info.reg, body)
251. c.drawString(info.x, y, label)
252. lx = info.x + sw(label, info.reg, body) + unit * 0.8
253. lx_end = lx + unit * 6.0
254. ly = y + body * 0.3
255. c.setStrokeColor(color)
256. c.setLineWidth(max(1.2, unit * 0.07))
257. if dashed:
258. d = max(5.0, unit * 0.6); c.setDash(d, d * 0.7)
259. c.line(lx, ly, lx_end, ly)
260. c.setDash()
261. info.y -= info.lead
264. def fmt(v):
265. return str(int(v)) if abs(v - round(v)) < 1e-6 else f"{v:.2f}".rstrip("0").rstrip(".")
268. def _inject_ocgs(path):
269. """Attach real OCG dictionaries so the BDC/EMC markers become toggleable layers."""
270. pdf = pikepdf.open(path, allow_overwriting_input=True)
271. ocgs, name_to_ocg = [], {}
272. for n in LAYERS:
273. ocg = pdf.make_indirect(pikepdf.Dictionary(Type=pikepdf.Name("/OCG"), Name=n))
274. ocgs.append(ocg); name_to_ocg[n] = ocg
275. pdf.Root.OCProperties = pikepdf.Dictionary(
276. OCGs=pikepdf.Array(ocgs),
277. D=pikepdf.Dictionary(Order=pikepdf.Array(ocgs),
278. ON=pikepdf.Array(ocgs),
279. OFF=pikepdf.Array([])),
280. )
281. page = pdf.pages[0]
282. props = pikepdf.Dictionary()
283. for n in LAYERS:
284. props[pikepdf.Name("/OC_" + n.replace(" ", "_"))] = name_to_ocg[n]
285. page.Resources[pikepdf.Name("/Properties")] = props
286. pdf.save(path)
287. pdf.close()
290. def main():
291. ap = argparse.ArgumentParser()
292. ap.add_argument("--sku", required=True)
293. ap.add_argument("--name", required=True)
294. ap.add_argument("--bleed-w", type=float, required=True, help="artwork-with-bleed width (in) = solid black boundary")
295. ap.add_argument("--bleed-h", type=float, required=True, help="artwork-with-bleed height (in)")
296. ap.add_argument("--visual-w", type=float, default=None, help="visual/safe area width (in) = red dashed line")
297. ap.add_argument("--visual-h", type=float, default=None, help="visual/safe area height (in)")
298. ap.add_argument("--safe-margin", type=float, default=2.0, help="uniform safe inset (in) used only when --visual-w/h omitted")
299. ap.add_argument("--out", required=True)
300. a = ap.parse_args()
301. build(a.sku, a.name, a.bleed_w, a.bleed_h, a.visual_w, a.visual_h, a.safe_margin, a.out)
302. print(f"Wrote {a.out}")
305. if __name__ == "__main__":
306. main()