Coverage for tasks/ace3.py: 53%

1""" 

2camcops_server/tasks/ace3.py 

3 

4=============================================================================== 

5 

6 Copyright (C) 2012, University of Cambridge, Department of Psychiatry. 

7 Created by Rudolf Cardinal (rnc1001@cam.ac.uk). 

8 

9 This file is part of CamCOPS. 

10 

11 CamCOPS is free software: you can redistribute it and/or modify 

12 it under the terms of the GNU General Public License as published by 

13 the Free Software Foundation, either version 3 of the License, or 

14 (at your option) any later version. 

15 

16 CamCOPS is distributed in the hope that it will be useful, 

17 but WITHOUT ANY WARRANTY; without even the implied warranty of 

18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

19 GNU General Public License for more details. 

20 

21 You should have received a copy of the GNU General Public License 

22 along with CamCOPS. If not, see <https://www.gnu.org/licenses/>. 

23 

24=============================================================================== 

25 

26ACE-III and Mini-ACE. 

27 

28""" 

29 

30from typing import Any, cast, Iterable, List, Optional, Type 

31 

32from cardinal_pythonlib.stringfunc import strseq 

33import cardinal_pythonlib.rnc_web as ws 

34import numpy 

35from sqlalchemy.orm import Mapped, mapped_column 

36from sqlalchemy.sql.sqltypes import Integer, String, UnicodeText 

37 

38from camcops_server.cc_modules.cc_blob import ( 

39 Blob, 

40 blob_relationship, 

41 get_blob_img_html, 

42) 

43from camcops_server.cc_modules.cc_constants import CssClass, PlotDefaults, PV 

44from camcops_server.cc_modules.cc_ctvinfo import CTV_INCOMPLETE, CtvInfo 

45from camcops_server.cc_modules.cc_db import add_multiple_columns 

46from camcops_server.cc_modules.cc_html import ( 

47 answer, 

48 get_yes_no_none, 

49 italic, 

50 pmid, 

51 subheading_spanning_two_columns, 

52 tr, 

53 tr_qa, 

54 tr_span_col, 

55) 

56from camcops_server.cc_modules.cc_request import CamcopsRequest 

57from camcops_server.cc_modules.cc_snomed import SnomedExpression, SnomedLookup 

58from camcops_server.cc_modules.cc_sqla_coltypes import ( 

59 BIT_CHECKER, 

60 mapped_camcops_column, 

61 PermittedValueChecker, 

62) 

63from camcops_server.cc_modules.cc_summaryelement import SummaryElement 

64from camcops_server.cc_modules.cc_task import ( 

65 Task, 

66 TaskHasClinicianMixin, 

67 TaskHasPatientMixin, 

68) 

69from camcops_server.cc_modules.cc_trackerhelpers import TrackerInfo 

70 

71 

72# ============================================================================= 

73# Constants 

74# ============================================================================= 

75 

76ADDRESS_PARTS = [ 

77 "forename", 

78 "surname", 

79 "number", 

80 "street_1", 

81 "street_2", 

82 "town", 

83 "county", 

84] 

85RECALL_WORDS = ["lemon", "key", "ball"] 

86PERCENT_DP = 1 

87 

88TOTAL_MAX = 100 

89ATTN_MAX = 18 

90MEMORY_MAX = 26 

91FLUENCY_MAX = 14 

92LANG_MAX = 26 

93VSP_MAX = 16 

94 

95ATTN_MINIACE_MAX = 4 

96MEM_MINIACE_MAX = 14 

97FLUENCY_MINIACE_MAX = 7 

98VSP_MINIACE_MAX = 5 

99MINI_ACE_MAX = 30 

100 

101AGE_FTE = "Age on leaving full-time education" 

102OCCUPATION = "Occupation" 

103HANDEDNESS = "Handedness" 

104N_ATTN_TIME_ACE = 5 

105N_ATTN_TIME_MINIACE = 4 

106N_MEM_REPEAT_RECALL_ADDR = 7 

107ANIMAL_FLUENCY_SCORING_HTML = ( 

108 "Score for animals <i>(≥22 scores 7, 17–21 scores 6, 14–16 scores 5, " 

109 "11–13 scores 4, 9–10 scores 3, 7–8 scores 2, 5–6 scores 1, " 

110 "&lt;5 scores 0)</i>" 

111) 

112ACE3_COPYRIGHT = """ 

113ACE-III: Copyright © 2012, John Hodges. “The ACE-III is available for free. The 

114copyright is held by Professor John Hodges who is happy for the test to be used 

115in clinical practice and research projects. There is no need to contact us if 

116you wish to use the ACE-III in clinical practice.” (ACE-III FAQ, 7 July 2013, 

117www.neura.edu.au). 

118""" 

119MINI_ACE_THRESHOLDS = f""" 

120In the mini-ACE, scores ≤21 had sensitivity 0.61 and specificity 1.0 for 

121dementia, and scores ≤25 had sensitivity 0.85 and specificity 0.87 for 

122dementia, in a context of patients with Alzheimer’s disease, behavioural 

123variant frontotemporal dementia, corticobasal syndrome, primary progressive 

124aphasia, and controls (Hsieh et al. 2015, {pmid(25227877)}. 

125""" 

126 

127 

128# ============================================================================= 

129# Ancillary functions 

130# ============================================================================= 

131 

132 

133def score_zero_for_absent(x: Optional[int]) -> int: 

134 """0 if x is None else x""" 

135 return 0 if x is None else x 

136 

137 

138def percent(score: int, maximum: int) -> str: 

139 return ws.number_to_dp(100 * score / maximum, PERCENT_DP) 

140 

141 

142def tr_score_with_pct(title: str, score: int, maximum: int) -> str: 

143 return tr( 

144 title, 

145 answer(score) + f" / {maximum} ({percent(score, maximum)}%)", 

146 ) 

147 

148 

149def qsequence(target_addr_parts: Iterable[str]) -> str: 

150 """ 

151 For e.g. "Harry? Barnes? ..." 

152 """ 

153 return " ".join(f"{x}?" for x in target_addr_parts) 

154 

155 

156def tr_heading(left: str, right: str) -> str: 

157 """ 

158 HTML for header row of most tables. 

159 """ 

160 return f""" 

161 <tr> 

162 <th width="67%">{left}</th> 

163 <th width="33%">{right}</th> 

164 </tr> 

165 """ 

166 

167 

168# ============================================================================= 

169# ACE-III 

170# ============================================================================= 

171 

172 

173class Ace3(TaskHasPatientMixin, TaskHasClinicianMixin, Task): # type: ignore[misc] # noqa: E501 

174 """ 

175 Server implementation of the ACE-III task. 

176 """ 

177 

178 __tablename__ = "ace3" 

179 shortname = "ACE-III" 

180 provides_trackers = True 

181 

182 prohibits_commercial = True 

183 

184 @classmethod 

185 def extend_columns(cls: Type["Ace3"], **kwargs: Any) -> None: 

186 add_multiple_columns( 

187 cls, 

188 "attn_time", 

189 1, 

190 5, 

191 pv=PV.BIT, 

192 comment_fmt="Attention, time, {n}/5, {s} (0 or 1)", 

193 comment_strings=["day", "date", "month", "year", "season"], 

194 ) 

195 add_multiple_columns( 

196 cls, 

197 "attn_place", 

198 1, 

199 5, 

200 pv=PV.BIT, 

201 comment_fmt="Attention, place, {n}/5, {s} (0 or 1)", 

202 comment_strings=[ 

203 "house number/floor", 

204 "street/hospital", 

205 "town", 

206 "county", 

207 "country", 

208 ], 

209 ) 

210 add_multiple_columns( 

211 cls, 

212 "attn_repeat_word", 

213 1, 

214 3, 

215 pv=PV.BIT, 

216 comment_fmt="Attention, repeat word, {n}/3, {s} (0 or 1)", 

217 comment_strings=RECALL_WORDS, 

218 ) 

219 add_multiple_columns( 

220 cls, 

221 "attn_serial7_subtraction", 

222 1, 

223 5, 

224 pv=PV.BIT, 

225 comment_fmt="Attention, serial sevens, {n}/5 (0 or 1)", 

226 ) 

227 

228 add_multiple_columns( 

229 cls, 

230 "mem_recall_word", 

231 1, 

232 3, 

233 pv=PV.BIT, 

234 comment_fmt="Memory, recall word, {n}/3, {s} (0 or 1)", 

235 comment_strings=RECALL_WORDS, 

236 ) 

237 add_multiple_columns( 

238 cls, 

239 "mem_repeat_address_trial1_", 

240 1, 

241 N_MEM_REPEAT_RECALL_ADDR, 

242 pv=PV.BIT, 

243 comment_fmt="Memory, address registration trial 1/3 " 

244 "(not scored), {s} (0 or 1)", 

245 comment_strings=ADDRESS_PARTS, 

246 ) 

247 add_multiple_columns( 

248 cls, 

249 "mem_repeat_address_trial2_", 

250 1, 

251 N_MEM_REPEAT_RECALL_ADDR, 

252 pv=PV.BIT, 

253 comment_fmt="Memory, address registration trial 2/3 " 

254 "(not scored), {s} (0 or 1)", 

255 comment_strings=ADDRESS_PARTS, 

256 ) 

257 add_multiple_columns( 

258 cls, 

259 "mem_repeat_address_trial3_", 

260 1, 

261 N_MEM_REPEAT_RECALL_ADDR, 

262 pv=PV.BIT, 

263 comment_fmt="Memory, address registration trial 3/3 " 

264 "(scored), {s} (0 or 1)", 

265 comment_strings=ADDRESS_PARTS, 

266 ) 

267 add_multiple_columns( 

268 cls, 

269 "mem_famous", 

270 1, 

271 4, 

272 pv=PV.BIT, 

273 comment_fmt="Memory, famous people, {n}/4, {s} (0 or 1)", 

274 comment_strings=["current PM", "woman PM", "USA president", "JFK"], 

275 ) 

276 

277 add_multiple_columns( 

278 cls, 

279 "lang_follow_command", 

280 1, 

281 3, 

282 pv=PV.BIT, 

283 comment_fmt="Language, command {n}/3 (0 or 1)", 

284 ) 

285 add_multiple_columns( 

286 cls, 

287 "lang_write_sentences_point", 

288 1, 

289 2, 

290 pv=PV.BIT, 

291 comment_fmt="Language, write sentences, {n}/2, {s} (0 or 1)", 

292 comment_strings=[ 

293 "two sentences on same topic", 

294 "grammar/spelling", 

295 ], 

296 ) 

297 add_multiple_columns( 

298 cls, 

299 "lang_repeat_word", 

300 1, 

301 4, 

302 pv=PV.BIT, 

303 comment_fmt="Language, repeat word, {n}/4, {s} (0 or 1)", 

304 comment_strings=[ 

305 "caterpillar", 

306 "eccentricity", 

307 "unintelligible", 

308 "statistician", 

309 ], 

310 ) 

311 add_multiple_columns( 

312 cls, 

313 "lang_repeat_sentence", 

314 1, 

315 2, 

316 pv=PV.BIT, 

317 comment_fmt="Language, repeat sentence, {n}/2, {s} (0 or 1)", 

318 comment_strings=["glitters_gold", "stitch_time"], 

319 ) 

320 add_multiple_columns( 

321 cls, 

322 "lang_name_picture", 

323 1, 

324 12, 

325 pv=PV.BIT, 

326 comment_fmt="Language, name picture, {n}/12, {s} (0 or 1)", 

327 comment_strings=[ 

328 "spoon", 

329 "book", 

330 "kangaroo/wallaby", 

331 "penguin", 

332 "anchor", 

333 "camel/dromedary", 

334 "harp", 

335 "rhinoceros", 

336 "barrel/keg/tub", 

337 "crown", 

338 "alligator/crocodile", 

339 "accordion/piano accordion/squeeze box", 

340 ], 

341 ) 

342 add_multiple_columns( 

343 cls, 

344 "lang_identify_concept", 

345 1, 

346 4, 

347 pv=PV.BIT, 

348 comment_fmt="Language, identify concept, {n}/4, {s} (0 or 1)", 

349 comment_strings=["monarchy", "marsupial", "Antarctic", "nautical"], 

350 ) 

351 

352 add_multiple_columns( 

353 cls, 

354 "vsp_count_dots", 

355 1, 

356 4, 

357 pv=PV.BIT, 

358 comment_fmt="Visuospatial, count dots {n}/4, {s} dots (0-1)", 

359 comment_strings=["8", "10", "7", "9"], 

360 ) 

361 add_multiple_columns( 

362 cls, 

363 "vsp_identify_letter", 

364 1, 

365 4, 

366 pv=PV.BIT, 

367 comment_fmt="Visuospatial, identify letter {n}/4, {s} (0-1)", 

368 comment_strings=["K", "M", "A", "T"], 

369 ) 

370 add_multiple_columns( 

371 cls, 

372 "mem_recall_address", 

373 1, 

374 N_MEM_REPEAT_RECALL_ADDR, 

375 pv=PV.BIT, 

376 comment_fmt="Memory, recall address {n}/7, {s} (0-1)", 

377 comment_strings=ADDRESS_PARTS, 

378 ) 

379 add_multiple_columns( 

380 cls, 

381 "mem_recognize_address", 

382 1, 

383 5, 

384 pv=PV.BIT, 

385 comment_fmt="Memory, recognize address {n}/5 (if " 

386 "applicable) ({s}) (0-1)", 

387 comment_strings=["name", "number", "street", "town", "county"], 

388 ) 

389 add_multiple_columns( # tablet version 2.0.0 onwards 

390 cls, 

391 "mem_recognize_address_choice", 

392 1, 

393 5, 

394 coltype=String(length=1), # was Text 

395 comment_fmt="Memory, recognize address {n}/5, CHOICE (if " 

396 "applicable) ({s}) (A/B/C)", 

397 comment_strings=["name", "number", "street", "town", "county"], 

398 ) 

399 

400 task_edition: Mapped[Optional[str]] = mapped_camcops_column( 

401 String(length=255), 

402 comment="Task edition. Older task instances will have NULL and that " 

403 "indicates UK English, 2012 version.", 

404 ) 

405 task_address_version: Mapped[Optional[str]] = mapped_camcops_column( 

406 String(length=1), 

407 comment="Task version, determining the address for recall (A/B/C). " 

408 "Older task instances will have NULL and that indicates version A.", 

409 permitted_value_checker=PermittedValueChecker( 

410 permitted_values=["A", "B", "C"] 

411 ), 

412 ) 

413 remote_administration: Mapped[Optional[bool]] = mapped_camcops_column( 

414 permitted_value_checker=BIT_CHECKER, 

415 comment="Task performed using remote (videoconferencing) " 

416 "administration?", 

417 ) 

418 age_at_leaving_full_time_education: Mapped[Optional[int]] = mapped_column( 

419 comment="Age at leaving full time education", 

420 ) 

421 occupation: Mapped[Optional[str]] = mapped_column( 

422 UnicodeText, comment="Occupation" 

423 ) 

424 handedness: Mapped[Optional[str]] = mapped_camcops_column( 

425 String(length=1), # was Text 

426 comment="Handedness (L or R)", 

427 permitted_value_checker=PermittedValueChecker( 

428 permitted_values=["L", "R"] 

429 ), 

430 ) 

431 attn_num_registration_trials: Mapped[Optional[int]] = mapped_column( 

432 comment="Attention, repetition, number of trials (not scored)", 

433 ) 

434 fluency_letters_score: Mapped[Optional[int]] = mapped_camcops_column( 

435 comment="Fluency, words beginning with P, score 0-7", 

436 permitted_value_checker=PermittedValueChecker(minimum=0, maximum=7), 

437 ) 

438 fluency_animals_score: Mapped[Optional[int]] = mapped_camcops_column( 

439 comment="Fluency, animals, score 0-7", 

440 permitted_value_checker=PermittedValueChecker(minimum=0, maximum=7), 

441 ) 

442 lang_follow_command_practice: Mapped[Optional[int]] = ( 

443 mapped_camcops_column( 

444 comment="Language, command, practice trial (not scored)", 

445 permitted_value_checker=BIT_CHECKER, 

446 ) 

447 ) 

448 lang_read_words_aloud: Mapped[Optional[int]] = mapped_camcops_column( 

449 comment="Language, read five irregular words (0 or 1)", 

450 permitted_value_checker=BIT_CHECKER, 

451 ) 

452 vsp_copy_infinity: Mapped[Optional[int]] = mapped_camcops_column( 

453 comment="Visuospatial, copy infinity (0-1)", 

454 permitted_value_checker=BIT_CHECKER, 

455 ) 

456 vsp_copy_cube: Mapped[Optional[int]] = mapped_camcops_column( 

457 comment="Visuospatial, copy cube (0-2)", 

458 permitted_value_checker=PermittedValueChecker(minimum=0, maximum=2), 

459 ) 

460 vsp_draw_clock: Mapped[Optional[int]] = mapped_camcops_column( 

461 comment="Visuospatial, draw clock (0-5)", 

462 permitted_value_checker=PermittedValueChecker(minimum=0, maximum=5), 

463 ) 

464 picture1_blobid: Mapped[Optional[int]] = mapped_camcops_column( 

465 comment="Photo 1/2 PNG BLOB ID", 

466 is_blob_id_field=True, 

467 blob_relationship_attr_name="picture1", 

468 ) 

469 picture2_blobid: Mapped[Optional[int]] = mapped_camcops_column( 

470 comment="Photo 2/2 PNG BLOB ID", 

471 is_blob_id_field=True, 

472 blob_relationship_attr_name="picture2", 

473 ) 

474 comments: Mapped[Optional[str]] = mapped_column( 

475 UnicodeText, comment="Clinician's comments" 

476 ) 

477 

478 picture1: Mapped[Optional[Blob]] = blob_relationship( # type: ignore[assignment] # noqa: E501 

479 "Ace3", "picture1_blobid" 

480 ) 

481 picture2: Mapped[Optional[Blob]] = blob_relationship( # type: ignore[assignment] # noqa: E501 

482 "Ace3", "picture2_blobid" 

483 ) 

484 

485 ATTN_SCORE_FIELDS = ( 

486 strseq("attn_time", 1, N_ATTN_TIME_ACE) 

487 + strseq("attn_place", 1, 5) 

488 + strseq("attn_repeat_word", 1, 3) 

489 + strseq("attn_serial7_subtraction", 1, 5) 

490 ) 

491 MEM_NON_RECOG_SCORE_FIELDS = ( 

492 strseq("mem_recall_word", 1, 3) 

493 + strseq("mem_repeat_address_trial3_", 1, N_MEM_REPEAT_RECALL_ADDR) 

494 + strseq("mem_famous", 1, 4) 

495 + strseq("mem_recall_address", 1, N_MEM_REPEAT_RECALL_ADDR) 

496 ) 

497 LANG_SIMPLE_SCORE_FIELDS = ( 

498 strseq("lang_write_sentences_point", 1, 2) 

499 + strseq("lang_repeat_sentence", 1, 2) 

500 + strseq("lang_name_picture", 1, 12) 

501 + strseq("lang_identify_concept", 1, 4) 

502 ) 

503 LANG_FOLLOW_CMD_FIELDS = strseq("lang_follow_command", 1, 3) 

504 LANG_REPEAT_WORD_FIELDS = strseq("lang_repeat_word", 1, 4) 

505 VSP_SIMPLE_SCORE_FIELDS = strseq("vsp_count_dots", 1, 4) + strseq( 

506 "vsp_identify_letter", 1, 4 

507 ) 

508 BASIC_COMPLETENESS_FIELDS = ( 

509 ATTN_SCORE_FIELDS 

510 + MEM_NON_RECOG_SCORE_FIELDS 

511 + ["fluency_letters_score", "fluency_animals_score"] 

512 + ["lang_follow_command_practice"] 

513 + LANG_SIMPLE_SCORE_FIELDS 

514 + LANG_REPEAT_WORD_FIELDS 

515 + [ 

516 "lang_read_words_aloud", 

517 "vsp_copy_infinity", 

518 "vsp_copy_cube", 

519 "vsp_draw_clock", 

520 ] 

521 + VSP_SIMPLE_SCORE_FIELDS 

522 + strseq("mem_recall_address", 1, N_MEM_REPEAT_RECALL_ADDR) 

523 ) 

524 MINI_ACE_FIELDS = ( 

525 strseq("attn_time", 1, N_ATTN_TIME_MINIACE) # 4 points; not season 

526 + ["fluency_animals_score"] # 7 points 

527 + strseq("mem_repeat_address_trial3_", 1, N_MEM_REPEAT_RECALL_ADDR) 

528 # ... 7 points 

529 + ["vsp_draw_clock"] # 5 points 

530 + strseq("mem_recall_address", 1, N_MEM_REPEAT_RECALL_ADDR) # 7 points 

531 ) 

532 

533 @staticmethod 

534 def longname(req: "CamcopsRequest") -> str: 

535 _ = req.gettext 

536 return _("Addenbrooke’s Cognitive Examination III") 

537 

538 def get_trackers(self, req: CamcopsRequest) -> List[TrackerInfo]: 

539 return [ 

540 TrackerInfo( 

541 value=self.total_score(), 

542 plot_label="ACE-III total score", 

543 axis_label=f"Total score (out of {TOTAL_MAX})", 

544 axis_min=-0.5, 

545 axis_max=TOTAL_MAX + 0.5, 

546 # Traditional cutoffs: ≤82, ≤88 

547 horizontal_lines=[82.5, 88.5], 

548 ), 

549 TrackerInfo( 

550 value=self.mini_ace_score(), 

551 plot_label="Mini-ACE score", 

552 axis_label=f"Mini-ACE score (out of {MINI_ACE_MAX})", 

553 axis_min=-0.5, 

554 axis_max=MINI_ACE_MAX + 0.5, 

555 # Traditional cutoffs: ≤21, ≤25 

556 horizontal_lines=[21.5, 25.5], 

557 ), 

558 ] 

559 

560 def get_clinical_text(self, req: CamcopsRequest) -> List[CtvInfo]: 

561 if not self.is_complete(): 

562 return CTV_INCOMPLETE 

563 a = self.attn_score() 

564 m = self.mem_score() 

565 f = self.fluency_score() 

566 lang = self.lang_score() 

567 v = self.vsp_score() 

568 t = a + m + f + lang + v 

569 mini = self.mini_ace_score() 

570 text = ( 

571 f"ACE-III total: {t}/{TOTAL_MAX} " 

572 f"(attention {a}/{ATTN_MAX}, memory {m}/{MEMORY_MAX}, " 

573 f"fluency {f}/{FLUENCY_MAX}, language {lang}/{LANG_MAX}, " 

574 f"visuospatial {v}/{VSP_MAX}, " 

575 f"mini-ACE score {mini}/{MINI_ACE_MAX})" 

576 ) 

577 return [CtvInfo(content=text)] 

578 

579 def get_summaries(self, req: CamcopsRequest) -> List[SummaryElement]: 

580 return self.standard_task_summary_fields() + [ 

581 SummaryElement( 

582 name="total", 

583 coltype=Integer(), 

584 value=self.total_score(), 

585 comment=f"Total score (/{TOTAL_MAX})", 

586 ), 

587 SummaryElement( 

588 name="attn", 

589 coltype=Integer(), 

590 value=self.attn_score(), 

591 comment=f"Attention (/{ATTN_MAX})", 

592 ), 

593 SummaryElement( 

594 name="mem", 

595 coltype=Integer(), 

596 value=self.mem_score(), 

597 comment=f"Memory (/{MEMORY_MAX})", 

598 ), 

599 SummaryElement( 

600 name="fluency", 

601 coltype=Integer(), 

602 value=self.fluency_score(), 

603 comment=f"Fluency (/{FLUENCY_MAX})", 

604 ), 

605 SummaryElement( 

606 name="lang", 

607 coltype=Integer(), 

608 value=self.lang_score(), 

609 comment=f"Language (/{LANG_MAX})", 

610 ), 

611 SummaryElement( 

612 name="vsp", 

613 coltype=Integer(), 

614 value=self.vsp_score(), 

615 comment=f"Visuospatial (/{VSP_MAX})", 

616 ), 

617 SummaryElement( 

618 name="mini_ace", 

619 coltype=Integer(), 

620 value=self.mini_ace_score(), 

621 comment=f"Mini-ACE (/{MINI_ACE_MAX})", 

622 ), 

623 ] 

624 

625 def attn_score(self) -> int: 

626 return cast(int, self.sum_fields(self.ATTN_SCORE_FIELDS)) 

627 

628 @staticmethod 

629 def get_recog_score( 

630 recalled: Optional[int], recognized: Optional[int] 

631 ) -> int: 

632 if recalled == 1: 

633 return 1 

634 return score_zero_for_absent(recognized) 

635 

636 @staticmethod 

637 def get_recog_text( 

638 recalled: Optional[int], recognized: Optional[int] 

639 ) -> str: 

640 if recalled: 

641 return "<i>1 (already recalled)</i>" 

642 return answer(recognized) 

643 

644 # noinspection PyUnresolvedReferences 

645 def get_mem_recognition_score(self) -> int: 

646 score = 0 

647 score += self.get_recog_score( 

648 (self.mem_recall_address1 == 1 and self.mem_recall_address2 == 1), # type: ignore[attr-defined] # noqa: E501 

649 self.mem_recognize_address1, # type: ignore[attr-defined] 

650 ) 

651 score += self.get_recog_score( 

652 (self.mem_recall_address3 == 1), self.mem_recognize_address2 # type: ignore[attr-defined] # noqa: E501 

653 ) 

654 score += self.get_recog_score( 

655 (self.mem_recall_address4 == 1 and self.mem_recall_address5 == 1), # type: ignore[attr-defined] # noqa: E501 

656 self.mem_recognize_address3, # type: ignore[attr-defined] 

657 ) 

658 score += self.get_recog_score( 

659 (self.mem_recall_address6 == 1), self.mem_recognize_address4 # type: ignore[attr-defined] # noqa: E501 

660 ) 

661 score += self.get_recog_score( 

662 (self.mem_recall_address7 == 1), self.mem_recognize_address5 # type: ignore[attr-defined] # noqa: E501 

663 ) 

664 return score 

665 

666 def mem_score(self) -> int: 

667 return cast( 

668 int, 

669 ( 

670 self.sum_fields(self.MEM_NON_RECOG_SCORE_FIELDS) 

671 + self.get_mem_recognition_score() 

672 ), 

673 ) 

674 

675 def fluency_score(self) -> int: 

676 return cast( 

677 int, 

678 ( 

679 score_zero_for_absent(self.fluency_letters_score) 

680 + score_zero_for_absent(self.fluency_animals_score) 

681 ), 

682 ) 

683 

684 def get_follow_command_score(self) -> int: 

685 if self.lang_follow_command_practice != 1: 

686 return 0 

687 return cast(int, self.sum_fields(self.LANG_FOLLOW_CMD_FIELDS)) 

688 

689 def get_repeat_word_score(self) -> int: 

690 n = cast(int, self.sum_fields(self.LANG_REPEAT_WORD_FIELDS)) 

691 return 2 if n >= 4 else (1 if n == 3 else 0) 

692 

693 def lang_score(self) -> int: 

694 return ( 

695 cast(int, self.sum_fields(self.LANG_SIMPLE_SCORE_FIELDS)) 

696 + self.get_follow_command_score() 

697 + self.get_repeat_word_score() 

698 + score_zero_for_absent(self.lang_read_words_aloud) 

699 ) 

700 

701 def vsp_score(self) -> int: 

702 return ( 

703 cast(int, self.sum_fields(self.VSP_SIMPLE_SCORE_FIELDS)) 

704 + score_zero_for_absent(self.vsp_copy_infinity) 

705 + score_zero_for_absent(self.vsp_copy_cube) 

706 + score_zero_for_absent(self.vsp_draw_clock) 

707 ) 

708 

709 def total_score(self) -> int: 

710 return ( 

711 self.attn_score() 

712 + self.mem_score() 

713 + self.fluency_score() 

714 + self.lang_score() 

715 + self.vsp_score() 

716 ) 

717 

718 def mini_ace_score(self) -> int: 

719 return cast(int, self.sum_fields(self.MINI_ACE_FIELDS)) 

720 

721 # noinspection PyUnresolvedReferences 

722 def is_recognition_complete(self) -> bool: 

723 return ( 

724 ( 

725 ( 

726 self.mem_recall_address1 == 1 # type: ignore[attr-defined] 

727 and self.mem_recall_address2 == 1 # type: ignore[attr-defined] # noqa: E501 

728 ) 

729 or self.mem_recognize_address1 is not None # type: ignore[attr-defined] # noqa: E501 

730 ) 

731 and ( 

732 self.mem_recall_address3 == 1 # type: ignore[attr-defined] 

733 or self.mem_recognize_address2 is not None # type: ignore[attr-defined] # noqa: E501 

734 ) 

735 and ( 

736 ( 

737 self.mem_recall_address4 == 1 # type: ignore[attr-defined] 

738 and self.mem_recall_address5 == 1 # type: ignore[attr-defined] # noqa: E501 

739 ) 

740 or self.mem_recognize_address3 is not None # type: ignore[attr-defined] # noqa: E501 

741 ) 

742 and ( 

743 self.mem_recall_address6 == 1 # type: ignore[attr-defined] 

744 or self.mem_recognize_address4 is not None # type: ignore[attr-defined] # noqa: E501 

745 ) 

746 and ( 

747 self.mem_recall_address7 == 1 # type: ignore[attr-defined] 

748 or self.mem_recognize_address5 is not None # type: ignore[attr-defined] # noqa: E501 

749 ) 

750 ) 

751 

752 def is_complete(self) -> bool: 

753 if self.any_fields_none(self.BASIC_COMPLETENESS_FIELDS): 

754 return False 

755 if not self.field_contents_valid(): 

756 return False 

757 if self.lang_follow_command_practice == 1 and self.any_fields_none( 

758 self.LANG_FOLLOW_CMD_FIELDS 

759 ): 

760 return False 

761 return self.is_recognition_complete() 

762 

763 @classmethod 

764 def get_target_address_parts( 

765 cls, req: CamcopsRequest, task_address_version: str 

766 ) -> List[str]: 

767 """ 

768 Returns the target address components (7 of them). This requires an 

769 xstring (via a request also embodying the currently selected locale) 

770 and the version selected for the task. 

771 

772 We do this as a classmethod so it (a) saves duplication and (b) knows 

773 about the xstrings for ACE-III (which are shared with the Mini-ACE). A 

774 superclass/mixin would be an alternative. 

775 """ 

776 parts = [] # type: List[str] 

777 for i in range(1, N_MEM_REPEAT_RECALL_ADDR + 1): 

778 xstringname = f"task_{task_address_version}_target_address_{i}" 

779 part = cls.xstring(req, xstringname) 

780 parts.append(part) 

781 return parts 

782 

783 # noinspection PyUnresolvedReferences 

784 def get_task_html(self, req: CamcopsRequest) -> str: 

785 a = self.attn_score() 

786 m = self.mem_score() 

787 f = self.fluency_score() 

788 lang = self.lang_score() 

789 v = self.vsp_score() 

790 t = a + m + f + lang + v 

791 mini = self.mini_ace_score() 

792 target_addr = qsequence( 

793 self.get_target_address_parts(req, self.task_address_version) 

794 ) 

795 lkb = qsequence(RECALL_WORDS) # lemon, key, ball 

796 

797 if self.is_complete(): 

798 figsize = ( 

799 PlotDefaults.FULLWIDTH_PLOT_WIDTH / 3, 

800 PlotDefaults.FULLWIDTH_PLOT_WIDTH / 4, 

801 ) 

802 width = 0.9 

803 fig = req.create_figure(figsize=figsize) 

804 ax = fig.add_subplot(1, 1, 1) 

805 scores = numpy.array([a, m, f, lang, v]) 

806 maxima = numpy.array( 

807 [ATTN_MAX, MEMORY_MAX, FLUENCY_MAX, LANG_MAX, VSP_MAX] 

808 ) 

809 y = 100 * scores / maxima 

810 x_labels = ["Attn", "Mem", "Flu", "Lang", "VSp"] 

811 # noinspection PyTypeChecker 

812 n = len(y) 

813 xvar = numpy.arange(n) 

814 ax.bar(xvar, y, width, color="b") 

815 ax.set_ylabel("%", fontdict=req.fontdict) 

816 ax.set_xticks(xvar) 

817 x_offset = -0.5 

818 ax.set_xlim(0 + x_offset, len(scores) + x_offset) 

819 ax.set_xticklabels(x_labels, fontdict=req.fontdict) 

820 fig.tight_layout() # or the ylabel drops off the figure 

821 # fig.autofmt_xdate() 

822 req.set_figure_font_sizes(ax) 

823 figurehtml = req.get_html_from_pyplot_figure(fig) 

824 else: 

825 figurehtml = "<i>Incomplete; not plotted</i>" 

826 

827 return ( 

828 self.get_standard_clinician_comments_block(req, self.comments) 

829 + f""" 

830 <div class="{CssClass.SUMMARY}"> 

831 <table class="{CssClass.SUMMARY}"> 

832 <tr> 

833 {self.get_is_complete_td_pair(req)} 

834 <td class="{CssClass.FIGURE}" 

835 rowspan="8">{figurehtml}</td> 

836 </tr> 

837 """ 

838 + tr( 

839 "Total ACE-III score ^[1]", 

840 answer(t) + f" / {TOTAL_MAX}", 

841 ) 

842 + tr_score_with_pct("Attention", a, ATTN_MAX) 

843 + tr_score_with_pct("Memory", m, MEMORY_MAX) 

844 + tr_score_with_pct("Fluency", f, FLUENCY_MAX) 

845 + tr_score_with_pct("Language", lang, LANG_MAX) 

846 + tr_score_with_pct("Visuospatial", v, VSP_MAX) 

847 + tr_score_with_pct( 

848 "Mini-ACE score ^[2]", mini, MINI_ACE_MAX 

849 ) 

850 + f""" 

851 </table> 

852 </div> 

853 <table class="{CssClass.TASKCONFIG}"> 

854 """ 

855 + tr_heading("Task aspect", "Setting") 

856 + tr_qa("Edition", self.task_edition) 

857 + tr_qa("Version", self.task_address_version) 

858 + tr_qa( 

859 "Remote administration?", 

860 get_yes_no_none(req, self.remote_administration), 

861 ) 

862 + f""" 

863 <table class="{CssClass.TASKDETAIL}"> 

864 """ 

865 + tr_heading("Question", "Answer/score") 

866 + tr_qa( 

867 AGE_FTE, 

868 self.age_at_leaving_full_time_education, 

869 ) 

870 + tr_qa(OCCUPATION, ws.webify(self.occupation)) 

871 + tr_qa(HANDEDNESS, ws.webify(self.handedness)) 

872 + subheading_spanning_two_columns("Attention") 

873 + tr( 

874 "Day? Date? Month? Year? Season?", 

875 ", ".join( 

876 answer(x) 

877 for x in ( 

878 self.attn_time1, # type: ignore[attr-defined] 

879 self.attn_time2, # type: ignore[attr-defined] 

880 self.attn_time3, # type: ignore[attr-defined] 

881 self.attn_time4, # type: ignore[attr-defined] 

882 self.attn_time5, # type: ignore[attr-defined] 

883 ) 

884 ), 

885 ) 

886 + tr( 

887 "House number/floor? Street/hospital? Town? County? Country?", 

888 ", ".join( 

889 answer(x) 

890 for x in ( 

891 self.attn_place1, # type: ignore[attr-defined] 

892 self.attn_place2, # type: ignore[attr-defined] 

893 self.attn_place3, # type: ignore[attr-defined] 

894 self.attn_place4, # type: ignore[attr-defined]