Coverage for liitos / meta.py: 76.83%

1"""Weave the content of the meta file(s) of metadata.tex.in into the output metadata.tex.""" 

2 

3import datetime as dti 

4import os 

5import pathlib 

6from typing import no_type_check 

7 

8import yaml 

9 

10import liitos.gather as gat 

11import liitos.template as tpl 

12import liitos.tools as too 

13from liitos import ENCODING, ExternalsType, KNOWN_APPROVALS_STRATEGIES, LOG_SEPARATOR, PathLike, log 

14 

15VALUE_SLOT = 'VALUE.SLOT' 

16DOC_BASE = pathlib.Path('..', '..') 

17STRUCTURE_PATH = DOC_BASE / 'structure.yml' 

18MAGIC_OF_TODAY = 'PUBLICATIONDATE' 

19SLASH = '\\' 

20 

21WEAVE_DEFAULTS = { 

22 'approvals_adjustable_vertical_space': '2.5em', 

23 'approvals_strategy': KNOWN_APPROVALS_STRATEGIES[0], 

24 'bold_font': 'ITCFranklinGothicStd-Demi', 

25 'bold_italic_font': 'ITCFranklinGothicStd-DemiIt', 

26 'bookmatter_path': '', 

27 'change_log_tune_header_sep': '-0em', 

28 'chosen_logo': '/opt/logo/liitos-logo.png', 

29 'chosen_title_page_logo': '/opt/logo/liitos-logo.png', 

30 'code_fontsize': r'\scriptsize', 

31 'driver_path': '', 

32 'fixed_font_package': 'sourcecodepro', 

33 'font_path': '/opt/fonts/', 

34 'font_suffix': '.otf', 

35 'footer_frame_note': os.getenv('LIITOS_FOOTER_FRAME_NOTE', ' '), # TODO 

36 'footer_outer_field_normal_pages': r'\theMetaPageNumPrefix { } \thepage { }', 

37 'italic_font': 'ITCFranklinGothicStd-BookIt', 

38 'lox_indent': r'\hspace*{0.40\textwidth}', # old default was '' for left align 

39 'main_font': 'ITCFranklinGothicStd-Book', 

40 'metadata_path': '', 

41 'proprietary_information': '/opt/legal/proprietary-information.txt', 

42 'proprietary_information_adjustable_vertical_space': '-0em', 

43 'proprietary_information_tune_header_sep': '-0em', 

44 'publisher_path': '', 

45 'setup_path': '', 

46 'stretch': '1.04', # old default was 1.2 

47 'table_captions_below': False, 

48 'table_uglify': False, 

49 'toc_all_dots': '', # old default was not toc all dots, so '%' would restore 

50} 

51ACROSS = { 

52 'eff_font_folder': '', 

53 'eff_font_suffix': '', 

54} 

55 

56 

57@no_type_check 

58def load(aspects: dict[str, str], doc_base: PathLike | None = None) -> gat.Meta | int: 

59 """Best effort loading of meta data. 

60 

61 Examples: 

62 

63 >>> aspects = {gat.KEY_META: 'missing-file'} 

64 >>> load(aspects) 

65 1 

66 

67 >>> doc_base = pathlib.Path('test/fixtures/basic/') 

68 >>> meta_name = 'empty-as-meta.yml' 

69 >>> aspects = {gat.KEY_META: meta_name} 

70 >>> load(aspects, doc_base) 

71 1 

72 

73 >>> doc_base = pathlib.Path('.') 

74 >>> aspects = {gat.KEY_META: __file__} 

75 >>> load(aspects, doc_base) 

76 2 

77 

78 >>> doc_base = pathlib.Path('test/fixtures/basic/') 

79 >>> meta_name = 'space-as-meta.yml' 

80 >>> str(doc_base) 

81 'test/fixtures/basic' 

82 >>> doc_base.is_dir() 

83 True 

84 >>> (doc_base / meta_name).is_file() 

85 True 

86 >>> (doc_base / meta_name).stat().st_size 

87 1 

88 >>> aspects = {gat.KEY_META: meta_name} 

89 >>> load(aspects, doc_base) 

90 3 

91 

92 >>> doc_base = pathlib.Path('test/fixtures/basic/') 

93 >>> str(doc_base) 

94 'test/fixtures/basic' 

95 >>> doc_base.is_dir() 

96 True 

97 >>> meta_name = 'meta-importing-empty-other-meta.yml' 

98 >>> aspects = {gat.KEY_META: meta_name} 

99 >>> load(aspects, doc_base) 

100 4 

101 """ 

102 doc_base = doc_base if doc_base is not None else DOC_BASE 

103 meta_path = doc_base / aspects[gat.KEY_META] 

104 if not meta_path.is_file() or not meta_path.stat().st_size: 104 ↛ 105line 104 didn't jump to line 105 because the condition on line 104 was never true

105 log.error(f'destructure failed to find non-empty meta file at {meta_path}') 

106 return 1 

107 if meta_path.suffix.lower() not in ('.yaml', '.yml'): 107 ↛ 108line 107 didn't jump to line 108 because the condition on line 107 was never true

108 return 2 

109 with open(meta_path, 'rt', encoding=ENCODING) as handle: 

110 metadata = yaml.safe_load(handle) 

111 if not metadata: 111 ↛ 112line 111 didn't jump to line 112 because the condition on line 111 was never true

112 log.error(f'empty metadata file? Please add metadata to ({meta_path})') 

113 return 3 

114 if 'import' in metadata['document']: 

115 base_meta_path = doc_base / metadata['document']['import'] 

116 if not base_meta_path.is_file() or not base_meta_path.stat().st_size: 116 ↛ 117line 116 didn't jump to line 117 because the condition on line 116 was never true

117 log.error( 

118 f'metadata declares import of base data from ({base_meta_path.name})' 

119 f' but failed to find non-empty base file at {base_meta_path}' 

120 ) 

121 return 4 

122 with open(base_meta_path, 'rt', encoding=ENCODING) as handle: 

123 base_data = yaml.safe_load(handle) 

124 for key, value in metadata['document']['patch'].items(): 

125 base_data['document']['common'][key] = value 

126 metadata = base_data 

127 with open('metadata.yml', 'wt', encoding=ENCODING) as handle: 

128 yaml.dump(metadata, handle, default_flow_style=False) 

129 return metadata 

130 

131 

132@no_type_check 

133def weave_setup_font_path( 

134 mapper: dict[str, str | int | bool | None], 

135 text: str, 

136) -> str: 

137 """Weave in the font_path from mapper or default for driver. 

138 

139 Trigger is text.rstrip().endswith('%%_PATCH_%_FONT_%_PATH_%%') 

140 

141 Examples: 

142 

143 >>> mapper = {'font_path': '/fonts/here/'} # expect warning if folder not present 

144 >>> weave_setup_font_path(mapper, 'Path = VALUE.SLOT,%%_PATCH_%_FONT_%_PATH_%%') 

145 'Path = /fonts/here/,%%_PATCH_%_FONT_%_PATH_%%' 

146 >>> ACROSS['eff_font_folder'] 

147 '/fonts/here/' 

148 

149 >>> mapper = {'no_font_path': 'sorry'} 

150 >>> weave_setup_font_path(mapper, 'Path = VALUE.SLOT,%%_PATCH_%_FONT_%_PATH_%%') 

151 'Path = /opt/fonts/,%%_PATCH_%_FONT_%_PATH_%%' 

152 >>> ACROSS['eff_font_folder'] 

153 '/opt/fonts/' 

154 """ 

155 defaults = {**WEAVE_DEFAULTS} 

156 if mapper.get('font_path'): 

157 font_path = mapper.get('font_path') 

158 if not pathlib.Path(font_path).is_dir(): 158 ↛ 159line 158 didn't jump to line 159 because the condition on line 158 was never true

159 log.warning(f'font_path ({font_path}) is no directory on this system - rendering may not work as intended') 

160 ACROSS['eff_font_folder'] = font_path 

161 return text.replace(VALUE_SLOT, font_path) 

162 else: 

163 log.warning(f'font_path value not set ... setting default ({defaults["font_path"]})') 

164 ACROSS['eff_font_folder'] = defaults['font_path'] 

165 return text.replace(VALUE_SLOT, defaults['font_path']) 

166 

167 

168@no_type_check 

169def weave_setup_font_suffix( 

170 mapper: dict[str, str | int | bool | None], 

171 text: str, 

172) -> str: 

173 """Weave in the font_suffix from mapper or default for driver. 

174 

175 Trigger is text.rstrip().endswith('%%_PATCH_%_FONT_%_SUFFIX_%%') 

176 

177 Examples: 

178 

179 >>> mapper = {'font_suffix': '.xtf'} # Expect warning because of unknown suffix for fonts 

180 >>> weave_setup_font_suffix(mapper, 'Extension = VALUE.SLOT,%%_PATCH_%_FONT_%_SUFFIX_%%') 

181 'Extension = .xtf,%%_PATCH_%_FONT_%_SUFFIX_%%' 

182 >>> ACROSS['eff_font_suffix'] 

183 '.xtf' 

184 

185 >>> mapper = {'no_font_suffix': 'sorry'} 

186 >>> weave_setup_font_suffix(mapper, 'Extension = VALUE.SLOT,%%_PATCH_%_FONT_%_SUFFIX_%%') 

187 'Extension = .otf,%%_PATCH_%_FONT_%_SUFFIX_%%' 

188 >>> ACROSS['eff_font_suffix'] 

189 '.otf' 

190 """ 

191 defaults = {**WEAVE_DEFAULTS} 

192 if mapper.get('font_suffix'): 

193 font_suffix = mapper.get('font_suffix') 

194 if font_suffix not in ('.otf', '.ttf'): 194 ↛ 195line 194 didn't jump to line 195 because the condition on line 194 was never true

195 log.warning(f'font_suffix ({font_suffix}) is unexpected - rendering may not work as intended') 

196 ACROSS['eff_font_suffix'] = font_suffix 

197 return text.replace(VALUE_SLOT, font_suffix) 

198 else: 

199 log.warning(f'font_suffix value not set ... setting default ({defaults["font_suffix"]})') 

200 ACROSS['eff_font_suffix'] = defaults['font_suffix'] 

201 return text.replace(VALUE_SLOT, defaults['font_suffix']) 

202 

203 

204@no_type_check 

205def weave_setup_bold_font( 

206 mapper: dict[str, str | int | bool | None], 

207 text: str, 

208) -> str: 

209 """Weave in the bold_font from mapper or default for driver. 

210 

211 Trigger is text.rstrip().endswith('%%_PATCH_%_BOLD_%_FONT_%%') 

212 

213 Examples: 

214 

215 >>> mapper = {'bold_font': 'MadeUp'} # Expect warning when file does not exist at font path and suffix 

216 >>> weave_setup_bold_font(mapper, 'BoldFont={VALUE.SLOT},%%_PATCH_%_BOLD_%_FONT_%%') 

217 'BoldFont={MadeUp},%%_PATCH_%_BOLD_%_FONT_%%' 

218 >>> assert ACROSS['eff_font_folder'] in ('', WEAVE_DEFAULTS['font_path']) 

219 >>> assert ACROSS['eff_font_suffix'] in ('', WEAVE_DEFAULTS['font_suffix']) 

220 

221 >>> mapper = {'no_bold_font': 'sorry'} 

222 >>> weave_setup_bold_font(mapper, 'BoldFont={VALUE.SLOT},%%_PATCH_%_BOLD_%_FONT_%%') 

223 'BoldFont={ITCFranklinGothicStd-Demi},%%_PATCH_%_BOLD_%_FONT_%%' 

224 >>> assert ACROSS['eff_font_folder'] in ('', WEAVE_DEFAULTS['font_path']) 

225 >>> assert ACROSS['eff_font_suffix'] in ('', WEAVE_DEFAULTS['font_suffix']) 

226 """ 

227 defaults = {**WEAVE_DEFAULTS} 

228 eff_font_folder = ACROSS['eff_font_folder'] 

229 eff_font_suffix = ACROSS['eff_font_suffix'] 

230 if mapper.get('bold_font'): 

231 bold_font = mapper.get('bold_font') 

232 font_path = pathlib.Path(eff_font_folder) / f'{bold_font}{eff_font_suffix}' 

233 if not font_path.is_file(): 233 ↛ 234line 233 didn't jump to line 234 because the condition on line 233 was never true

234 log.warning( 

235 f'bold_font ({bold_font}) is not found' 

236 f' as ({font_path}) on this system - rendering may not work as intended' 

237 ) 

238 return text.replace(VALUE_SLOT, bold_font) 

239 else: 

240 log.warning(f'bold_font value not set ... setting default ({defaults["bold_font"]})') 

241 return text.replace(VALUE_SLOT, defaults['bold_font']) 

242 

243 

244@no_type_check 

245def weave_setup_italic_font( 

246 mapper: dict[str, str | int | bool | None], 

247 text: str, 

248) -> str: 

249 """Weave in the italic_font from mapper or default for driver. 

250 

251 Trigger is text.rstrip().endswith('%%_PATCH_%_ITALIC_%_FONT_%%') 

252 

253 Examples: 

254 

255 >>> mapper = {'italic_font': 'MadeUpToo'} # Expect warning when file does not exist at font path and suffix 

256 >>> weave_setup_italic_font(mapper, 'ItalicFont={VALUE.SLOT},%%_PATCH_%_ITALIC_%_FONT_%%') 

257 'ItalicFont={MadeUpToo},%%_PATCH_%_ITALIC_%_FONT_%%' 

258 >>> assert ACROSS['eff_font_folder'] in ('', WEAVE_DEFAULTS['font_path']) 

259 >>> assert ACROSS['eff_font_suffix'] in ('', WEAVE_DEFAULTS['font_suffix']) 

260 

261 >>> mapper = {'no_italic_font': 'sorry'} 

262 >>> weave_setup_italic_font(mapper, 'ItalicFont={VALUE.SLOT},%%_PATCH_%_ITALIC_%_FONT_%%') 

263 'ItalicFont={ITCFranklinGothicStd-BookIt},%%_PATCH_%_ITALIC_%_FONT_%%' 

264 >>> assert ACROSS['eff_font_folder'] in ('', WEAVE_DEFAULTS['font_path']) 

265 >>> assert ACROSS['eff_font_suffix'] in ('', WEAVE_DEFAULTS['font_suffix']) 

266 """ 

267 defaults = {**WEAVE_DEFAULTS} 

268 eff_font_folder = ACROSS['eff_font_folder'] 

269 eff_font_suffix = ACROSS['eff_font_suffix'] 

270 if mapper.get('italic_font'): 

271 italic_font = mapper.get('italic_font') 

272 font_path = pathlib.Path(eff_font_folder) / f'{italic_font}{eff_font_suffix}' 

273 if not font_path.is_file(): 273 ↛ 274line 273 didn't jump to line 274 because the condition on line 273 was never true

274 log.warning( 

275 f'italic_font ({italic_font}) is not found' 

276 f' as ({font_path}) on this system - rendering may not work as intended' 

277 ) 

278 return text.replace(VALUE_SLOT, italic_font) 

279 else: 

280 log.warning(f'italic_font value not set ... setting default ({defaults["italic_font"]})') 

281 return text.replace(VALUE_SLOT, defaults['italic_font']) 

282 

283 

284@no_type_check 

285def weave_setup_bold_italic_font( 

286 mapper: dict[str, str | int | bool | None], 

287 text: str, 

288) -> str: 

289 """Weave in the bold_italic_font from mapper or default for driver. 

290 

291 Trigger is text.rstrip().endswith('%%_PATCH_%_BOLDITALIC_%_FONT_%%') 

292 

293 Examples: 

294 

295 >>> mapper = {'bold_italic_font': 'AlsoMadeUp'} # Expect warning when file does not exist at font path and suffix 

296 >>> weave_setup_bold_italic_font(mapper, 'BoldItalicFont={VALUE.SLOT}%%_PATCH_%_BOLDITALIC_%_FONT_%%') 

297 'BoldItalicFont={AlsoMadeUp}%%_PATCH_%_BOLDITALIC_%_FONT_%%' 

298 >>> assert ACROSS['eff_font_folder'] in ('', WEAVE_DEFAULTS['font_path']) 

299 >>> assert ACROSS['eff_font_suffix'] in ('', WEAVE_DEFAULTS['font_suffix']) 

300 

301 >>> mapper = {'no_bold_italic_font': 'sorry'} 

302 >>> weave_setup_bold_italic_font(mapper, 'BoldItalicFont={VALUE.SLOT}%%_PATCH_%_BOLDITALIC_%_FONT_%%') 

303 'BoldItalicFont={ITCFranklinGothicStd-DemiIt}%%_PATCH_%_BOLDITALIC_%_FONT_%%' 

304 >>> assert ACROSS['eff_font_folder'] in ('', WEAVE_DEFAULTS['font_path']) 

305 >>> assert ACROSS['eff_font_suffix'] in ('', WEAVE_DEFAULTS['font_suffix']) 

306 """ 

307 defaults = {**WEAVE_DEFAULTS} 

308 eff_font_folder = ACROSS['eff_font_folder'] 

309 eff_font_suffix = ACROSS['eff_font_suffix'] 

310 if mapper.get('bold_italic_font'): 

311 bold_italic_font = mapper.get('bold_italic_font') 

312 font_path = pathlib.Path(eff_font_folder) / f'{bold_italic_font}{eff_font_suffix}' 

313 if not font_path.is_file(): 313 ↛ 314line 313 didn't jump to line 314 because the condition on line 313 was never true

314 log.warning( 

315 f'bold_italic_font ({bold_italic_font}) is not found' 

316 f' as ({font_path}) on this system - rendering may not work as intended' 

317 ) 

318 return text.replace(VALUE_SLOT, bold_italic_font) 

319 else: 

320 log.warning(f'bold_italic_font value not set ... setting default ({defaults["bold_italic_font"]})') 

321 return text.replace(VALUE_SLOT, defaults['bold_italic_font']) 

322 

323 

324@no_type_check 

325def weave_setup_main_font( 

326 mapper: dict[str, str | int | bool | None], 

327 text: str, 

328) -> str: 

329 """Weave in the main_font from mapper or default for driver. 

330 

331 Trigger is text.rstrip().endswith('%%_PATCH_%_MAIN_%_FONT_%%') 

332 

333 Examples: 

334 

335 >>> mapper = {'main_font': 'IsMadeUp'} # Expect warning when file does not exist at font path and suffix 

336 >>> weave_setup_main_font(mapper, ']{VALUE.SLOT}%%_PATCH_%_MAIN_%_FONT_%%') 

337 ']{IsMadeUp}%%_PATCH_%_MAIN_%_FONT_%%' 

338 >>> assert ACROSS['eff_font_folder'] in ('', WEAVE_DEFAULTS['font_path']) 

339 >>> assert ACROSS['eff_font_suffix'] in ('', WEAVE_DEFAULTS['font_suffix']) 

340 

341 >>> mapper = {'no_main_font': 'sorry'} 

342 >>> weave_setup_main_font(mapper, ']{VALUE.SLOT}%%_PATCH_%_MAIN_%_FONT_%%') 

343 ']{ITCFranklinGothicStd-Book}%%_PATCH_%_MAIN_%_FONT_%%' 

344 >>> assert ACROSS['eff_font_folder'] in ('', WEAVE_DEFAULTS['font_path']) 

345 >>> assert ACROSS['eff_font_suffix'] in ('', WEAVE_DEFAULTS['font_suffix']) 

346 """ 

347 defaults = {**WEAVE_DEFAULTS} 

348 eff_font_folder = ACROSS['eff_font_folder'] 

349 eff_font_suffix = ACROSS['eff_font_suffix'] 

350 if mapper.get('main_font'): 

351 main_font = mapper.get('main_font') 

352 font_path = pathlib.Path(eff_font_folder) / f'{main_font}{eff_font_suffix}' 

353 if not font_path.is_file(): 353 ↛ 354line 353 didn't jump to line 354 because the condition on line 353 was never true

354 log.warning( 

355 f'main_font ({main_font}) is not found' 

356 f' as ({font_path}) on this system - rendering may not work as intended' 

357 ) 

358 return text.replace(VALUE_SLOT, main_font) 

359 else: 

360 log.warning(f'main_font value not set ... setting default ({defaults["main_font"]})') 

361 return text.replace(VALUE_SLOT, defaults['main_font']) 

362 

363 

364@no_type_check 

365def weave_setup_fixed_font_package( 

366 mapper: dict[str, str | int | bool | None], 

367 text: str, 

368) -> str: 

369 r"""Weave in the fixed_font_package from mapper or default for driver. 

370 

371 Trigger is text.rstrip().endswith('%%_PATCH_%_FIXED_%_FONT_%_PACKAGE_%%') 

372 

373 Examples: 

374 

375 >>> mapper = {'fixed_font_package': 'MadeUpAgain'} # Expect warning when font differs from default 

376 >>> weave_setup_fixed_font_package(mapper, r'\usepackage{VALUE.SLOT}%%_PATCH_%_FIXED_%_FONT_%_PACKAGE_%%') 

377 '\\usepackage{MadeUpAgain}%%_PATCH_%_FIXED_%_FONT_%_PACKAGE_%%' 

378 

379 >>> mapper = {'no_fixed_font_package': 'sorry'} 

380 >>> weave_setup_fixed_font_package(mapper, r'\usepackage{VALUE.SLOT}%%_PATCH_%_FIXED_%_FONT_%_PACKAGE_%%') 

381 '\\usepackage{sourcecodepro}%%_PATCH_%_FIXED_%_FONT_%_PACKAGE_%%' 

382 """ 

383 defaults = {**WEAVE_DEFAULTS} 

384 if mapper.get('fixed_font_package'): 

385 fixed_font_package = mapper.get('fixed_font_package') 

386 if fixed_font_package != defaults['fixed_font_package']: 386 ↛ 387line 386 didn't jump to line 387 because the condition on line 386 was never true

387 log.warning( 

388 f'fixed_font_package ({fixed_font_package}) has not' 

389 ' been tested on this system - rendering may not work as intended' 

390 ) 

391 return text.replace(VALUE_SLOT, fixed_font_package) 

392 else: 

393 log.warning(f'fixed_font_package value not set ... setting default ({defaults["fixed_font_package"]})') 

394 return text.replace(VALUE_SLOT, defaults['fixed_font_package']) 

395 

396 

397@no_type_check 

398def weave_setup_code_fontsize( 

399 mapper: dict[str, str | int | bool | None], 

400 text: str, 

401) -> str: 

402 r"""Weave in the code_fontsize from mapper or default for driver. 

403 

404 Trigger is text.rstrip().endswith('%%_PATCH_%_CODE_%_FONTSIZE_%%') 

405 

406 Examples: 

407 

408 >>> mapper = {'code_fontsize': r'\Huge'} 

409 >>> weave_setup_code_fontsize(mapper, 'fontsize=VALUE.SLOT}%%_PATCH_%_CODE_%_FONTSIZE_%%') 

410 'fontsize=\\Huge}%%_PATCH_%_CODE_%_FONTSIZE_%%' 

411 

412 >>> mapper = {'code_fontsize': r'footnotesize'} 

413 >>> weave_setup_code_fontsize(mapper, 'fontsize=VALUE.SLOT}%%_PATCH_%_CODE_%_FONTSIZE_%%') 

414 'fontsize=\\footnotesize}%%_PATCH_%_CODE_%_FONTSIZE_%%' 

415 

416 >>> mapper = {'code_fontsize': r'scriptsize'} 

417 >>> weave_setup_code_fontsize(mapper, 'fontsize=VALUE.SLOT}%%_PATCH_%_CODE_%_FONTSIZE_%%') 

418 'fontsize=\\scriptsize}%%_PATCH_%_CODE_%_FONTSIZE_%%' 

419 

420 >>> mapper = {'code_fontsize': r'tini'} # Expect warnings on override with available sizes 

421 >>> weave_setup_code_fontsize(mapper, 'fontsize=VALUE.SLOT}%%_PATCH_%_CODE_%_FONTSIZE_%%') 

422 'fontsize=\\scriptsize}%%_PATCH_%_CODE_%_FONTSIZE_%%' 

423 

424 >>> mapper = {'code_fontsize': r'\\LARGE'} 

425 >>> weave_setup_code_fontsize(mapper, 'fontsize=VALUE.SLOT}%%_PATCH_%_CODE_%_FONTSIZE_%%') 

426 'fontsize=\\LARGE}%%_PATCH_%_CODE_%_FONTSIZE_%%' 

427 

428 >>> mapper = {'no_code_fontsize': 'sorry'} 

429 >>> weave_setup_code_fontsize(mapper, 'fontsize=VALUE.SLOT}%%_PATCH_%_CODE_%_FONTSIZE_%%') 

430 'fontsize=\\scriptsize}%%_PATCH_%_CODE_%_FONTSIZE_%%' 

431 """ 

432 defaults = {**WEAVE_DEFAULTS} 

433 if mapper.get('code_fontsize'): 

434 code_fontsize = mapper.get('code_fontsize') 

435 valid_code_font_sizes = ( 

436 r'\Huge', 

437 r'\huge', 

438 r'\LARGE', 

439 r'\Large', 

440 r'\large', 

441 r'\normalsize', 

442 r'\small', 

443 r'\footnotesize', 

444 r'\scriptsize', 

445 r'\tiny', 

446 ) 

447 bs = '\\' 

448 sizes = tuple(size[1:] for size in valid_code_font_sizes) 

449 if code_fontsize.startswith(SLASH + SLASH): 449 ↛ 450line 449 didn't jump to line 450 because the condition on line 449 was never true

450 code_fontsize = code_fontsize[1:] 

451 if not code_fontsize.startswith(SLASH): 451 ↛ 452line 451 didn't jump to line 452 because the condition on line 451 was never true

452 code_fontsize = SLASH + code_fontsize 

453 if code_fontsize not in valid_code_font_sizes: 453 ↛ 454line 453 didn't jump to line 454 because the condition on line 453 was never true

454 log.error( 

455 f'code_fontsize ({code_fontsize}) is not a valid font size value' 

456 ' - rendering would not work as intended' 

457 ) 

458 log.info(f'valid values for code_fontsize must be in {bs}{(", " + bs).join(sizes)}') 

459 log.warning( 

460 f'overriding code font size value with the (working) default of ({defaults["code_fontsize"]})' 

461 f' - in config that would be {defaults["code_fontsize"]}' 

462 ) 

463 return text.replace(VALUE_SLOT, defaults['code_fontsize']) 

464 else: 

465 return text.replace(VALUE_SLOT, code_fontsize) 

466 else: 

467 log.info( 

468 f'code_fontsize value not set ... setting default ({defaults["code_fontsize"]})' 

469 f' - in config that would be {defaults["code_fontsize"]}' 

470 ) 

471 return text.replace(VALUE_SLOT, defaults['code_fontsize']) 

472 

473 

474@no_type_check 

475def weave_setup_chosen_logo( 

476 mapper: dict[str, str | int | bool | None], 

477 text: str, 

478) -> str: 

479 r"""Weave in the chosen_logo from mapper or default for driver. 

480 

481 Trigger is text.rstrip().endswith('%%_PATCH_%_CHOSEN_%_LOGO_%%') 

482 

483 Examples: 

484 

485 >>> mapper = {'chosen_logo': 'not-found.png'} # Expect warning when logo path is no file 

486 >>> weave_setup_chosen_logo(mapper, r'\newcommand{\theChosenLogo}{VALUE.SLOT}%%_PATCH_%_CHOSEN_%_LOGO_%%') 

487 '\\newcommand{\\theChosenLogo}{not-found.png}%%_PATCH_%_CHOSEN_%_LOGO_%%' 

488 

489 >>> mapper = {'no_chosen_logo': 'sorry'} 

490 >>> weave_setup_chosen_logo(mapper, r'\newcommand{\theChosenLogo}{VALUE.SLOT}%%_PATCH_%_CHOSEN_%_LOGO_%%') 

491 '\\newcommand{\\theChosenLogo}{/opt/logo/liitos-logo.png}%%_PATCH_%_CHOSEN_%_LOGO_%%' 

492 """ 

493 defaults = {**WEAVE_DEFAULTS} 

494 if mapper.get('chosen_logo'): 

495 chosen_logo = mapper.get('chosen_logo') 

496 logo_path = pathlib.Path(chosen_logo) 

497 if not logo_path.is_file(): 497 ↛ 498line 497 didn't jump to line 498 because the condition on line 497 was never true

498 log.warning( 

499 f'chosen_logo ({chosen_logo}) is not found' 

500 f' as ({logo_path}) on this system - rendering may not work as intended' 

501 ) 

502 return text.replace(VALUE_SLOT, chosen_logo) 

503 else: 

504 log.info(f'chosen_logo value not set ... setting default ({defaults["chosen_logo"]})') 

505 return text.replace(VALUE_SLOT, defaults['chosen_logo']) 

506 

507 

508@no_type_check 

509def weave_setup_chosen_title_page_logo( 

510 mapper: dict[str, str | int | bool | None], 

511 text: str, 

512) -> str: 

513 r"""Weave in the chosen_logo from mapper or default for driver. 

514 

515 Trigger is text.rstrip().endswith('%%_PATCH_%_CHOSEN_%_TITLE_%_PAGE_%_LOGO_%%') 

516 

517 Examples: 

518 

519 >>> mapper = {'chosen_title_page_logo': 'not-found.png'} # Expect warning when logo path is no file 

520 >>> t = r'\newcommand{\theChosenTitlePageLogo}{VALUE.SLOT}%%_PATCH_%_CHOSEN_%_TITLE_%_PAGE_%_LOGO_%%' 

521 >>> weave_setup_chosen_title_page_logo(mapper, t) 

522 '\\newcommand{\\theChosenTitlePageLogo}{not-found.png}%%_PATCH_%_CHOSEN_%_TITLE_%_PAGE_%_LOGO_%%' 

523 

524 >>> mapper = {'no_chosen_title_page_logo': 'sorry'} 

525 >>> t = r'\newcommand{\theChosenTitlePageLogo}{VALUE.SLOT}%%_PATCH_%_CHOSEN_%_TITLE_%_PAGE_%_LOGO_%%' 

526 >>> weave_setup_chosen_title_page_logo(mapper, t) 

527 '\\newcommand{\\theChosenTitlePageLogo}{/opt/logo/liitos-logo.png}%%_PATCH_%_CHOSEN_%_TITLE_%_PAGE_%_LOGO_%%' 

528 """ 

529 defaults = {**WEAVE_DEFAULTS} 

530 log.warning(text) 

531 if mapper.get('chosen_title_page_logo'): 

532 chosen_title_page_logo = mapper.get('chosen_title_page_logo') 

533 title_page_logo_path = pathlib.Path(chosen_title_page_logo) 

534 log.warning(f'found {chosen_title_page_logo}') 

535 if not title_page_logo_path.is_file(): 535 ↛ 536line 535 didn't jump to line 536 because the condition on line 535 was never true

536 log.warning( 

537 f'chosen_title_page_logo ({chosen_title_page_logo}) is not found' 

538 f' as ({title_page_logo_path}) on this system - rendering may not work as intended' 

539 ) 

540 return text.replace(VALUE_SLOT, chosen_title_page_logo) 

541 else: 

542 log.warning('default logo') 

543 log.info(f'chosen_title_page_logo value not set ... setting default ({defaults["chosen_title_page_logo"]})') 

544 return text.replace(VALUE_SLOT, defaults['chosen_title_page_logo']) 

545 

546 

547@no_type_check 

548def weave_setup_footer_outer_field_normal_pages( 

549 mapper: dict[str, str | int | bool | None], 

550 text: str, 

551) -> str: 

552 r"""Weave in the footer_outer_field_normal_pages from mapper or default for driver. 

553 

554 Trigger is text.rstrip().endswith('%%_PATCH_%_NORMAL_%_PAGES_%_OUTER_%_FOOT_%_CONTENT_%_VALUE_%%') 

555 

556 Examples: 

557 

558 >>> mapper = {'footer_outer_field_normal_pages': 'n/a'} 

559 >>> t = ' VALUE.SLOT}}%%_PATCH_%_NORMAL_%_PAGES_%_OUTER_%_FOOT_%_CONTENT_%_VALUE_%%' 

560 >>> weave_setup_footer_outer_field_normal_pages(mapper, t) 

561 ' n/a}}%%_PATCH_%_NORMAL_%_PAGES_%_OUTER_%_FOOT_%_CONTENT_%_VALUE_%%' 

562 

563 >>> mapper = {'footer_outer_field_normal_pages': ''} 

564 >>> t = ' VALUE.SLOT}}%%_PATCH_%_NORMAL_%_PAGES_%_OUTER_%_FOOT_%_CONTENT_%_VALUE_%%' 

565 >>> weave_setup_footer_outer_field_normal_pages(mapper, t) 

566 ' }}%%_PATCH_%_NORMAL_%_PAGES_%_OUTER_%_FOOT_%_CONTENT_%_VALUE_%%' 

567 

568 >>> mapper = {'no_footer_outer_field_normal_pages': 'sorry'} 

569 >>> t = ' VALUE.SLOT}}%%_PATCH_%_NORMAL_%_PAGES_%_OUTER_%_FOOT_%_CONTENT_%_VALUE_%%' 

570 >>> weave_setup_footer_outer_field_normal_pages(mapper, t) 

571 ' \\theMetaPageNumPrefix { } \\thepage { }}}%%_PATCH_%_NORMAL_%_PAGES_%_OUTER_%_FOOT_%_CONTENT_%_VALUE_%%' 

572 """ 

573 defaults = {**WEAVE_DEFAULTS} 

574 if mapper.get('footer_outer_field_normal_pages') is not None: 574 ↛ 578line 574 didn't jump to line 578 because the condition on line 574 was always true

575 footer_outer_field_normal_pages = mapper.get('footer_outer_field_normal_pages') 

576 return text.replace(VALUE_SLOT, footer_outer_field_normal_pages) 

577 else: 

578 log.info( 

579 'footer_outer_field_normal_pages value not set ...' 

580 f' setting default ({defaults["footer_outer_field_normal_pages"]})' 

581 ) 

582 return text.replace(VALUE_SLOT, defaults['footer_outer_field_normal_pages']) 

583 

584 

585@no_type_check 

586def weave_setup_toc_all_dots( 

587 mapper: dict[str, str | int | bool | None], 

588 text: str, 

589) -> str: 

590 r"""Weave in the toc_all_dots from mapper or default for driver. 

591 

592 Trigger is text.rstrip().endswith('%%_PATCH_%_TOC_ALL_DOTS_%%') 

593 

594 Examples: 

595 

596 >>> mapper = {'toc_all_dots': '%'} # Comment out the toc dots 

597 >>> weave_setup_toc_all_dots(mapper, 'VALUE.SLOTtoc=sectionentrywithdots,%%_PATCH_%_TOC_ALL_DOTS_%%') 

598 '%toc=sectionentrywithdots,%%_PATCH_%_TOC_ALL_DOTS_%%' 

599 

600 >>> mapper = {'toc_all_dots': ' '} # Enable the toc dots 

601 >>> weave_setup_toc_all_dots(mapper, 'VALUE.SLOTtoc=sectionentrywithdots,%%_PATCH_%_TOC_ALL_DOTS_%%') 

602 ' toc=sectionentrywithdots,%%_PATCH_%_TOC_ALL_DOTS_%%' 

603 

604 >>> mapper = {'toc_all_dots': '%-does-not-matter'} # Comment out the toc dots 

605 >>> weave_setup_toc_all_dots(mapper, 'VALUE.SLOTtoc=sectionentrywithdots,%%_PATCH_%_TOC_ALL_DOTS_%%') 

606 '%-does-not-mattertoc=sectionentrywithdots,%%_PATCH_%_TOC_ALL_DOTS_%%' 

607 

608 >>> mapper = {'toc_all_dots': 'missing-percent'} # Default toc dots and a warning 

609 >>> weave_setup_toc_all_dots(mapper, 'VALUE.SLOTtoc=sectionentrywithdots,%%_PATCH_%_TOC_ALL_DOTS_%%') 

610 'toc=sectionentrywithdots,%%_PATCH_%_TOC_ALL_DOTS_%%' 

611 

612 >>> mapper = {'no_toc_all_dots': 'sorry'} 

613 >>> weave_setup_toc_all_dots(mapper, 'VALUE.SLOTtoc=sectionentrywithdots,%%_PATCH_%_TOC_ALL_DOTS_%%') 

614 'toc=sectionentrywithdots,%%_PATCH_%_TOC_ALL_DOTS_%%' 

615 """ 

616 defaults = {**WEAVE_DEFAULTS} 

617 if mapper.get('toc_all_dots', None) is not None: 617 ↛ 618line 617 didn't jump to line 618 because the condition on line 617 was never true

618 toc_all_dots = mapper.get('toc_all_dots') 

619 if not toc_all_dots.strip() or toc_all_dots.strip().startswith('%'): 

620 dis_ = 'dis' if not toc_all_dots.strip() else '' 

621 log.info(f'toc_all_dots value received ... {dis_}abling toc dots') 

622 return text.replace(VALUE_SLOT, toc_all_dots) 

623 log.warning( 

624 f"toc_all_dots value is neither '' nor starts with % ... setting default ({defaults['toc_all_dots']})" 

625 ) 

626 return text.replace(VALUE_SLOT, defaults['toc_all_dots']) 

627 else: 

628 log.info(f'toc_all_dots value not set ... setting default ({defaults["toc_all_dots"]})') 

629 return text.replace(VALUE_SLOT, defaults['toc_all_dots']) 

630 

631 

632@no_type_check 

633def dispatch_setup_weaver( 

634 mapper: dict[str, str | int | bool | None], 

635 text: str, 

636) -> str: 

637 """Dispatch the driver weaver by mapping to handled groups per source marker.""" 

638 dispatch = { 

639 '%%_PATCH_%_FONT_%_PATH_%%': weave_setup_font_path, 

640 '%%_PATCH_%_FONT_%_SUFFIX_%%': weave_setup_font_suffix, 

641 '%%_PATCH_%_BOLD_%_FONT_%%': weave_setup_bold_font, 

642 '%%_PATCH_%_ITALIC_%_FONT_%%': weave_setup_italic_font, 

643 '%%_PATCH_%_BOLDITALIC_%_FONT_%%': weave_setup_bold_italic_font, 

644 '%%_PATCH_%_MAIN_%_FONT_%%': weave_setup_main_font, 

645 '%%_PATCH_%_FIXED_%_FONT_%_PACKAGE_%%': weave_setup_fixed_font_package, 

646 '%%_PATCH_%_CODE_%_FONTSIZE_%%': weave_setup_code_fontsize, 

647 '%%_PATCH_%_CHOSEN_%_LOGO_%%': weave_setup_chosen_logo, 

648 '%%_PATCH_%_CHOSEN_%_TITLE_%_PAGE_%_LOGO_%%': weave_setup_chosen_title_page_logo, 

649 '%%_PATCH_%_NORMAL_%_PAGES_%_OUTER_%_FOOT_%_CONTENT_%_VALUE_%%': weave_setup_footer_outer_field_normal_pages, 

650 '%%_PATCH_%_TOC_ALL_DOTS_%%': weave_setup_toc_all_dots, 

651 } 

652 for trigger, weaver in dispatch.items(): 

653 if text.rstrip().endswith(trigger): 

654 return weaver(mapper, text) 

655 return text 

656 

657 

658@no_type_check 

659def weave_meta_setup(meta_map: gat.Meta, latex: list[str]) -> list[str]: 

660 """TODO.""" 

661 log.info('weaving in the meta data per setup.tex.in into setup.tex ...') 

662 completed = [dispatch_setup_weaver(meta_map['document']['common'], line) for line in latex] 

663 if completed and completed[-1]: 

664 completed.append('\n') 

665 return completed 

666 

667 

668@no_type_check 

669def weave_driver_toc_level( 

670 mapper: dict[str, str | int | bool | None], 

671 text: str, 

672) -> str: 

673 """Weave in the toc_level from mapper or default for driver. 

674 

675 Trigger is text.rstrip().endswith('%%_PATCH_%_TOC_%_LEVEL_%%') 

676 """ 

677 toc_level = 2 

678 if mapper.get('toc_level'): 

679 try: 

680 toc_level_read = int(mapper['toc_level']) 

681 toc_level = toc_level_read if 0 < toc_level_read < 5 else 2 

682 if toc_level != toc_level_read: 

683 log.warning( 

684 f'ignored toc level ({toc_level_read}) set to default (2) - expected value 0 < toc_level < 5' 

685 ) 

686 except ValueError as err: 

687 toc_level = 2 

688 log.warning(f'toc_level ({mapper["toc_level"]}) not in (1, 2, 3, 4) - resorting to default ({toc_level})') 

689 log.error(f'error detail: {err}') 

690 else: 

691 log.info(f'toc_level value not set ... setting default ({toc_level})') 

692 return text.replace(VALUE_SLOT, str(toc_level)) 

693 

694 

695@no_type_check 

696def weave_driver_list_of_figures( 

697 mapper: dict[str, str | int | bool | None], 

698 text: str, 

699) -> str: 

700 """Weave in the list_of_figures from mapper or default for driver. 

701 

702 Trigger is text.rstrip().endswith('%%_PATCH_%_LOF_%%') 

703 """ 

704 if mapper.get('list_of_figures', None) is not None: 

705 lof = mapper['list_of_figures'] 

706 if lof in ('', '%'): 

707 return text.replace(VALUE_SLOT, str(lof)) 

708 else: 

709 lof = '%' 

710 log.warning( 

711 f"list_of_figures ({mapper['list_of_figures']}) not in ('', '%')" 

712 f' - resorting to default ({lof}) i.e. commenting out the list of figures' 

713 ) 

714 else: 

715 log.info('list_of_figures value not set ... setting default (comment out the lof per %)') 

716 

717 return text.replace(VALUE_SLOT, '%') 

718 

719 

720@no_type_check 

721def weave_driver_list_of_tables( 

722 mapper: dict[str, str | int | bool | None], 

723 text: str, 

724) -> str: 

725 """Weave in the list_of_tables from mapper or default for driver. 

726 

727 Trigger is text.rstrip().endswith('%%_PATCH_%_LOT_%%') 

728 """ 

729 if mapper.get('list_of_tables', None) is not None: 

730 lof = mapper['list_of_tables'] 

731 if lof in ('', '%'): 

732 return text.replace(VALUE_SLOT, str(lof)) 

733 else: 

734 lof = '%' 

735 log.warning( 

736 f"list_of_tables ({mapper['list_of_tables']}) not in ('', '%')" 

737 f' - resorting to default ({lof}) i.e. commenting out the list of tables' 

738 ) 

739 else: 

740 log.info('list_of_tables value not set ... setting default (comment out the lot per %)') 

741 

742 return text.replace(VALUE_SLOT, '%') 

743 

744 

745@no_type_check 

746def dispatch_driver_weaver( 

747 mapper: dict[str, str | int | bool | None], 

748 text: str, 

749) -> str: 

750 """Dispatch the driver weaver by mapping to handled groups per source marker.""" 

751 dispatch = { 

752 '%%_PATCH_%_TOC_%_LEVEL_%%': weave_driver_toc_level, 

753 '%%_PATCH_%_LOF_%%': weave_driver_list_of_figures, 

754 '%%_PATCH_%_LOT_%%': weave_driver_list_of_tables, 

755 } 

756 for trigger, weaver in dispatch.items(): 

757 if text.rstrip().endswith(trigger): 

758 return weaver(mapper, text) 

759 return text 

760 

761 

762@no_type_check 

763def weave_meta_driver(meta_map: gat.Meta, latex: list[str]) -> list[str]: 

764 """TODO.""" 

765 log.info('weaving in the meta data per driver.tex.in into driver.tex ...') 

766 completed = [dispatch_driver_weaver(meta_map['document']['common'], line) for line in latex] 

767 if completed and completed[-1]: 

768 completed.append('\n') 

769 return completed 

770 

771 

772@no_type_check 

773def weave_meta_part_header_title( 

774 mapper: dict[str, str | int | bool | None], 

775 text: str, 

776) -> str: 

777 """Weave in the header_title from mapper or default. 

778 

779 Trigger is text.rstrip().endswith('%%_PATCH_%_HEADER_%_TITLE_%%') 

780 """ 

781 if mapper.get('header_title'): 

782 return text.replace(VALUE_SLOT, mapper['header_title']) 

783 else: 

784 log.info('header_title value not set ... setting default (the title value)') 

785 return text.replace(VALUE_SLOT, mapper['title']) 

786 

787 

788@no_type_check 

789def weave_meta_part_title_slug( 

790 mapper: dict[str, str | int | bool | None], 

791 text: str, 

792) -> str: 

793 r"""Weave in the title slug deriving from mapper or default. 

794 

795 Trigger is text.rstrip().endswith('%%_PATCH_%_TITLE_%_SLUG_%%') 

796 

797 Examples: 

798 

799 >>> mapper = {'bookmark_title': 'I aM A BMT'} 

800 >>> t = r'\newcommand{\theTitleSlug}{VALUE.SLOT}%%_PATCH_%_TITLE_%_SLUG_%%' 

801 >>> weave_meta_part_title_slug(mapper, t) 

802 '\\newcommand{\\theTitleSlug}{I aM A BMT}%%_PATCH_%_TITLE_%_SLUG_%%' 

803 """ 

804 if mapper.get('bookmark_title'): 804 ↛ 805line 804 didn't jump to line 805 because the condition on line 804 was never true

805 return text.replace(VALUE_SLOT, mapper['bookmark_title']) 

806 else: 

807 log.info('bookmark_title value not set ... setting default (the slugged title value)') 

808 return text.replace(VALUE_SLOT, mapper['title'].replace('\\\\', '').replace(' ', ' ').title()) 

809 

810 

811@no_type_check 

812def weave_meta_part_title( 

813 mapper: dict[str, str | int | bool | None], 

814 text: str, 

815) -> str: 

816 """Weave in the title from mapper or default. 

817 

818 Trigger is text.rstrip().endswith('%%_PATCH_%_MAIN_%_TITLE_%%') 

819 """ 

820 return text.replace(VALUE_SLOT, mapper['title']) 

821 

822 

823@no_type_check 

824def weave_meta_part_sub_title( 

825 mapper: dict[str, str | int | bool | None], 

826 text: str, 

827) -> str: 

828 """Weave in the sub_title from mapper or default. 

829 

830 Trigger is text.rstrip().endswith('%%_PATCH_%_SUB_%_TITLE_%%') 

831 """ 

832 if mapper.get('sub_title'): 

833 return text.replace(VALUE_SLOT, mapper['sub_title']) 

834 else: 

835 log.info('sub_title value not set ... setting default (single space)') 

836 return text.replace(VALUE_SLOT, ' ') 

837 

838 

839@no_type_check 

840def weave_meta_part_header_type( 

841 mapper: dict[str, str | int | bool | None], 

842 text: str, 

843) -> str: 

844 """Weave in the header_type from mapper or default. 

845 

846 Trigger is text.rstrip().endswith('%%_PATCH_%_TYPE_%%') 

847 """ 

848 if mapper.get('header_type'): 

849 return text.replace(VALUE_SLOT, mapper['header_type']) 

850 else: 

851 log.info('header_type value not set ... setting default (Engineering Document)') 

852 return text.replace(VALUE_SLOT, 'Engineering Document') 

853 

854 

855@no_type_check 

856def weave_meta_part_header_id_label( 

857 mapper: dict[str, str | int | bool | None], 

858 text: str, 

859) -> str: 

860 r"""Weave in the header_id_label from mapper or default. 

861 

862 Trigger is text.rstrip().endswith('%%_PATCH_%_ID_%_LABEL_%%') 

863 

864 Examples: 

865 

866 >>> mapper = {'header_id_show': False} 

867 >>> t = r'\newcommand{\theMetaDocIdLabel}{VALUE.SLOT}%%_PATCH_%_ID_%_LABEL_%%' 

868 >>> weave_meta_part_header_id_label(mapper, t) 

869 '\\newcommand{\\theMetaDocIdLabel}{ }%%_PATCH_%_ID_%_LABEL_%%' 

870 

871 >>> mapper = {'header_id_show': ''} 

872 >>> t = r'\newcommand{\theMetaDocIdLabel}{VALUE.SLOT}%%_PATCH_%_ID_%_LABEL_%%' 

873 >>> weave_meta_part_header_id_label(mapper, t) 

874 '\\newcommand{\\theMetaDocIdLabel}{ }%%_PATCH_%_ID_%_LABEL_%%' 

875 

876 >>> mapper = {'header_id_show': None, 'header_id_label': ' '} 

877 >>> t = r'\newcommand{\theMetaDocIdLabel}{VALUE.SLOT}%%_PATCH_%_ID_%_LABEL_%%' 

878 >>> weave_meta_part_header_id_label(mapper, t) 

879 '\\newcommand{\\theMetaDocIdLabel}{ }%%_PATCH_%_ID_%_LABEL_%%' 

880 

881 >>> mapper = {'header_id_show': None, 'header_id_label': ' show-this-stripped '} 

882 >>> t = r'\newcommand{\theMetaDocIdLabel}{VALUE.SLOT}%%_PATCH_%_ID_%_LABEL_%%' 

883 >>> weave_meta_part_header_id_label(mapper, t) 

884 '\\newcommand{\\theMetaDocIdLabel}{show-this-stripped}%%_PATCH_%_ID_%_LABEL_%%' 

885 

886 >>> mapper = {'no_header_id_show': 'sorry'} 

887 >>> t = r'\newcommand{\theMetaDocIdLabel}{VALUE.SLOT}%%_PATCH_%_ID_%_LABEL_%%' 

888 >>> weave_meta_part_header_id_label(mapper, t) 

889 '\\newcommand{\\theMetaDocIdLabel}{Doc. ID:}%%_PATCH_%_ID_%_LABEL_%%' 

890 """ 

891 if mapper.get('header_id_show', None) is not None and not mapper['header_id_show']: 891 ↛ 892line 891 didn't jump to line 892 because the condition on line 891 was never true