def get_trackers(self, req: CamcopsRequest) -> List[TrackerInfo]:
return [
TrackerInfo(
value=self.total_score(),
plot_label="PHQ-9 total score (rating depressive symptoms)",
axis_label=f"Score for Q1-9 (out of {self.MAX_SCORE_MAIN})",
axis_min=-0.5,
axis_max=self.MAX_SCORE_MAIN + 0.5,
axis_ticks=[
TrackerAxisTick(27, "27"),
TrackerAxisTick(25, "25"),
TrackerAxisTick(20, "20"),
TrackerAxisTick(15, "15"),
TrackerAxisTick(10, "10"),
TrackerAxisTick(5, "5"),
TrackerAxisTick(0, "0"),
],
horizontal_lines=[19.5, 14.5, 9.5, 4.5],
horizontal_labels=[
TrackerLabel(23, req.sstring(SS.SEVERE)),
TrackerLabel(17, req.sstring(SS.MODERATELY_SEVERE)),
TrackerLabel(12, req.sstring(SS.MODERATE)),
TrackerLabel(7, req.sstring(SS.MILD)),
TrackerLabel(2.25, req.sstring(SS.NONE)),
],
)
]
def get_task_html(self, req: CamcopsRequest) -> str:
score = self.total_score()
exceeds_cutoff_1 = score >= 6
exceeds_cutoff_2 = score >= 11
main_dict = {
None: None,
"Y": req.sstring(SS.YES),
"N": req.sstring(SS.NO),
}
q_a = ""
for q in range(1, Dast.NQUESTIONS + 1):
q_a += tr(
self.wxstring(req, "q" + str(q)),
answer(get_from_dict(main_dict, getattr(self, "q" + str(q)))) +
" — " + answer(str(self.get_score(q))),
)
h = """
<div class="{CssClass.SUMMARY}">
<table class="{CssClass.SUMMARY}">
{tr_is_complete}
{total_score}
{exceeds_standard_cutoff_1}
{exceeds_standard_cutoff_2}
</table>
</div>
<table class="{CssClass.TASKDETAIL}">
<tr>
<th width="80%">Question</th>
<th width="20%">Answer</th>
</tr>
{q_a}
</table>
<div class="{CssClass.COPYRIGHT}">
DAST: Copyright © Harvey A. Skinner and the Centre for
Addiction and Mental Health, Toronto, Canada.
Reproduced here under the permissions granted for
NON-COMMERCIAL use only. You must obtain permission from the
copyright holder for any other use.
</div>
""".format(
CssClass=CssClass,
tr_is_complete=self.get_is_complete_tr(req),
total_score=tr(
req.sstring(SS.TOTAL_SCORE),
answer(score) + f" / {self.NQUESTIONS}",
),
exceeds_standard_cutoff_1=tr_qa(
self.wxstring(req, "exceeds_standard_cutoff_1"),
get_yes_no(req, exceeds_cutoff_1),
),
exceeds_standard_cutoff_2=tr_qa(
self.wxstring(req, "exceeds_standard_cutoff_2"),
get_yes_no(req, exceeds_cutoff_2),
),
q_a=q_a,
)
return h
def severity(self, req: CamcopsRequest) -> str:
score = self.total_score()
if score >= 31:
return req.sstring(SS.VERY_SEVERE)
elif score >= 25:
return req.sstring(SS.MODERATE_TO_SEVERE)
elif score >= 18:
return req.sstring(SS.MILD_TO_MODERATE)
else:
return req.sstring(SS.MILD)
def severity(self, req: CamcopsRequest) -> str:
score = self.total_score()
if score >= 15:
return req.sstring(SS.SEVERE)
elif score >= 10:
return req.sstring(SS.MODERATE)
elif score >= 5:
return req.sstring(SS.MILD)
else:
return req.sstring(SS.NONE)
def get_task_html(self, req: CamcopsRequest) -> str:
score = self.total_score()
likelihood = self.likelihood(req)
main_dict = {
None: None,
"Y": req.sstring(SS.YES),
"N": req.sstring(SS.NO),
}
q_a = ""
for q in range(1, self.NQUESTIONS + 1):
q_a += tr(
self.wxstring(req, "q" + str(q)),
answer(get_from_dict(main_dict, getattr(self, "q" + str(q))))
+ " — "
+ str(self.get_score(q)),
)
h = """
<div class="{CssClass.SUMMARY}">
<table class="{CssClass.SUMMARY}">
{tr_is_complete}
{total_score}
{problem_likelihood}
</table>
</div>
<table class="{CssClass.TASKDETAIL}">
<tr>
<th width="80%">Question</th>
<th width="20%">Answer</th>
</tr>
{q_a}
</table>
<div class="{CssClass.FOOTNOTES}">
[1] Total score ≥3 probable, ≥2 possible, 0–1 unlikely.
</div>
""".format(
CssClass=CssClass,
tr_is_complete=self.get_is_complete_tr(req),
total_score=tr(
req.sstring(SS.TOTAL_SCORE),
answer(score) + f" / {self.NQUESTIONS}",
),
problem_likelihood=tr_qa(
self.wxstring(req, "problem_likelihood") + " <sup>[1]</sup>",
likelihood,
),
q_a=q_a,
)
return h
def get_task_html(self, req: CamcopsRequest) -> str:
main_dict = {
None: None,
0: "0 — " + self.wxstring(req, "q1to3_option0"),
1: "1 — " + self.wxstring(req, "q1to3_option1"),
2: "2 — " + self.wxstring(req, "q1to3_option2"),
3: "3 — " + self.wxstring(req, "q1to3_option3"),
4: "4 — " + self.wxstring(req, "q1to3_option4"),
}
q4_dict = {
None: None,
0: "0 — " + self.wxstring(req, "q4_option0"),
2: "2 — " + self.wxstring(req, "q4_option2"),
4: "4 — " + self.wxstring(req, "q4_option4"),
}
q_a = tr_qa(self.wxstring(req, "q1"),
get_from_dict(main_dict, self.q1))
q_a += tr_qa(self.wxstring(req, "q2"),
get_from_dict(main_dict, self.q2))
q_a += tr_qa(self.wxstring(req, "q3"),
get_from_dict(main_dict, self.q3))
q_a += tr_qa(self.wxstring(req, "q4"), get_from_dict(q4_dict, self.q4))
tr_total_score = tr(
req.sstring(SS.TOTAL_SCORE),
answer(self.total_score()) + f" / {self.MAX_SCORE}",
)
tr_positive = tr_qa(
self.wxstring(req, "positive") + " <sup>[1]</sup>",
get_yes_no(req, self.is_positive()),
)
return f"""
def category(self, req: CamcopsRequest) -> str:
score = self.total_score()
if self.highschooleducation == 1:
if score >= 27:
return req.sstring(SS.NORMAL)
elif score >= 21:
return self.wxstring(req, "category_mci")
else:
return self.wxstring(req, "category_dementia")
else:
if score >= 25:
return req.sstring(SS.NORMAL)
elif score >= 20:
return self.wxstring(req, "category_mci")
else:
return self.wxstring(req, "category_dementia")
def get_task_html(self, req: CamcopsRequest) -> str:
score = self.total_score()
severity = self.severity(req)
answer_dict = {None: None}
for option in range(0, 4):
answer_dict[option] = (str(option) + " — " +
self.wxstring(req, "a" + str(option)))
q_a = ""
for q in range(1, self.NQUESTIONS + 1):
q_a += tr_qa(
self.wxstring(req, "q" + str(q)),
get_from_dict(answer_dict, getattr(self, "q" + str(q))),
)
return """
<div class="{CssClass.SUMMARY}">
<table class="{CssClass.SUMMARY}">
{tr_is_complete}
{total_score}
{anxiety_severity}
</table>
</div>
<div class="{CssClass.EXPLANATION}">
Ratings are over the last 2 weeks.
</div>
<table class="{CssClass.TASKDETAIL}">
<tr>
<th width="50%">Question</th>
<th width="50%">Answer</th>
</tr>
{q_a}
</table>
<div class="{CssClass.FOOTNOTES}">
[1] ≥15 severe, ≥10 moderate, ≥5 mild.
Score ≥10 identifies: generalized anxiety disorder with
sensitivity 89%, specificity 82% (Spitzer et al. 2006, PubMed
ID 16717171);
panic disorder with sensitivity 74%, specificity 81% (Kroenke
et al. 2010, PMID 20633738);
social anxiety with sensitivity 72%, specificity 80% (Kroenke
et al. 2010);
post-traumatic stress disorder with sensitivity 66%,
specificity 81% (Kroenke et al. 2010).
The majority of evidence contributing to these figures comes
from primary care screening studies.
</div>
""".format(
CssClass=CssClass,
tr_is_complete=self.get_is_complete_tr(req),
total_score=tr(
req.sstring(SS.TOTAL_SCORE),
answer(score) + " / {}".format(self.MAX_SCORE),
),
anxiety_severity=tr(
self.wxstring(req, "anxiety_severity") + " <sup>[1]</sup>",
severity,
),
q_a=q_a,
)
def get_task_html(self, req: CamcopsRequest) -> str:
def bprs_string(x: str) -> str:
return req.wxstring("bprs", x)
main_dict = {
None: None,
0: "0 — " + bprs_string("old_option0"),
1: "1 — " + bprs_string("old_option1"),
2: "2 — " + bprs_string("old_option2"),
3: "3 — " + bprs_string("old_option3"),
4: "4 — " + bprs_string("old_option4"),
5: "5 — " + bprs_string("old_option5"),
6: "6 — " + bprs_string("old_option6"),
7: "7 — " + bprs_string("old_option7"),
}
q_a = ""
for i in range(1, self.NQUESTIONS + 1):
q_a += tr_qa(
self.wxstring(req, "q" + str(i) + "_s"),
get_from_dict(main_dict, getattr(self, "q" + str(i))),
)
total_score = tr(
req.sstring(SS.TOTAL_SCORE) +
f" (0–{self.MAX_SCORE}; 24–{self.MAX_SCORE} if all rated)",
answer(self.total_score()),
)
return f"""
def get_trackers(self, req: CamcopsRequest) -> List[TrackerInfo]:
return [
TrackerInfo(
value=self.total_score(),
plot_label="CIWA total score",
axis_label=f"Total score (out of {self.MAX_SCORE})",
axis_min=-0.5,
axis_max=self.MAX_SCORE + 0.5,
horizontal_lines=[14.5, 7.5],
horizontal_labels=[
TrackerLabel(17, req.sstring(SS.SEVERE)),
TrackerLabel(11, req.sstring(SS.MODERATE)),
TrackerLabel(3.75, req.sstring(SS.MILD)),
],
)
]
def get_task_html(self, req: CamcopsRequest) -> str:
score = self.total_score()
exceeds_threshold = self.exceeds_ross_threshold()
main_dict = {
None: None,
"Y": req.sstring(SS.YES),
"N": req.sstring(SS.NO),
}
q_a = ""
for q in range(1, self.NQUESTIONS + 1):
q_a += tr(
self.wxstring(req, "q" + str(q)),
(answer(get_from_dict(main_dict, getattr(self, "q" + str(q))))
+ answer(" — " + str(self.get_score(q)))),
)
return f"""
def get_task_html(self, req: CamcopsRequest) -> str:
score = self.total_score()
severity = self.severity(req)
answer_dicts_dict = {}
for q in self.SCORED_QUESTIONS:
d = {None: None}
for option in range(0, 8):
if option > 4 and q == "q10":
continue
d[option] = self.wxstring(req, q + "_option" + str(option))
answer_dicts_dict[q] = d
q_a = ""
for q in range(1, Ciwa.NSCOREDQUESTIONS + 1):
q_a += tr_qa(
self.wxstring(req, "q" + str(q) + "_s"),
get_from_dict(
answer_dicts_dict["q" + str(q)],
getattr(self, "q" + str(q)),
),
)
tr_total_score = tr(req.sstring(SS.TOTAL_SCORE),
answer(score) + f" / {self.MAX_SCORE}")
tr_severity = tr_qa(
self.wxstring(req, "severity") + " <sup>[1]</sup>", severity)
return f"""
def get_trackers(self, req: CamcopsRequest) -> List[TrackerInfo]:
return [
TrackerInfo(
value=self.total_score(),
plot_label="GAD-7 total score",
axis_label="Total score (out of 21)",
axis_min=-0.5,
axis_max=self.MAX_SCORE + 0.5,
horizontal_lines=[14.5, 9.5, 4.5],
horizontal_labels=[
TrackerLabel(17, req.sstring(SS.SEVERE)),
TrackerLabel(12, req.sstring(SS.MODERATE)),
TrackerLabel(7, req.sstring(SS.MILD)),
TrackerLabel(2.25, req.sstring(SS.NONE)),
],
)
]
def get_trackers(self, req: CamcopsRequest) -> List[TrackerInfo]:
return [
TrackerInfo(
value=self.total_score(),
plot_label="PHQ-15 total score (rating somatic symptoms)",
axis_label=f"Score for Q1-15 (out of {self.MAX_TOTAL})",
axis_min=-0.5,
axis_max=self.MAX_TOTAL + 0.5,
horizontal_lines=[14.5, 9.5, 4.5],
horizontal_labels=[
TrackerLabel(22, req.sstring(SS.SEVERE)),
TrackerLabel(12, req.sstring(SS.MODERATE)),
TrackerLabel(7, req.sstring(SS.MILD)),
TrackerLabel(2.25, req.sstring(SS.NONE)),
],
)
]
def get_trackers(self, req: CamcopsRequest) -> List[TrackerInfo]:
return [
TrackerInfo(
value=self.total_score(),
plot_label="HAM-A total score",
axis_label=f"Total score (out of {self.MAX_SCORE})",
axis_min=-0.5,
axis_max=self.MAX_SCORE + 0.5,
horizontal_lines=[30.5, 24.5, 17.5],
horizontal_labels=[
TrackerLabel(33, req.sstring(SS.VERY_SEVERE)),
TrackerLabel(27.5, req.sstring(SS.MODERATE_TO_SEVERE)),
TrackerLabel(21, req.sstring(SS.MILD_TO_MODERATE)),
TrackerLabel(8.75, req.sstring(SS.MILD)),
],
)
]
def get_trackers(self, req: CamcopsRequest) -> List[TrackerInfo]:
return [
TrackerInfo(
value=self.total_score(),
plot_label="MOCA total score",
axis_label=f"Total score (out of {self.MAX_SCORE})",
axis_min=-0.5,
axis_max=(self.MAX_SCORE + 0.5),
horizontal_lines=[25.5],
horizontal_labels=[
TrackerLabel(26, req.sstring(SS.NORMAL),
LabelAlignment.bottom),
TrackerLabel(25, req.sstring(SS.ABNORMAL),
LabelAlignment.top),
],
)
]
def get_task_html(self, req: CamcopsRequest) -> str:
main_dict = {
None: None,
1: "1 — " + self.wxstring(req, "wemwbs_a1"),
2: "2 — " + self.wxstring(req, "wemwbs_a2"),
3: "3 — " + self.wxstring(req, "wemwbs_a3"),
4: "4 — " + self.wxstring(req, "wemwbs_a4"),
5: "5 — " + self.wxstring(req, "wemwbs_a5"),
}
q_a = ""
for i in range(1, self.N_QUESTIONS + 1):
nstr = str(i)
q_a += tr_qa(
self.wxstring(req, "wemwbs_q" + nstr),
get_from_dict(main_dict, getattr(self, "q" + nstr)),
)
h = """
<div class="{css_summary}">
<table class="{css_summary}">
{tr_is_complete}
{tr_total_score}
</table>
</div>
<div class="{css_explanation}">
Ratings are over the last 2 weeks.
</div>
<table class="{css_taskdetail}">
<tr>
<th width="60%">Question</th>
<th width="40%">Answer</th>
</tr>
{q_a}
</table>
<div class="{css_copyright}">
WEMWBS: from Tennant et al. (2007), <i>Health and Quality of
Life Outcomes</i> 5:63,
<a href="http://www.hqlo.com/content/5/1/63">
http://www.hqlo.com/content/5/1/63</a>;
© 2007 Tennant et al.; distributed under the terms of the
Creative Commons Attribution License.
</div>
""".format(
css_summary=CssClass.SUMMARY,
tr_is_complete=self.get_is_complete_tr(req),
tr_total_score=tr(
req.sstring(SS.TOTAL_SCORE),
answer(self.total_score())
+ f" (range {self.MINTOTALSCORE}–{self.MAXTOTALSCORE})",
),
css_explanation=CssClass.EXPLANATION,
css_taskdetail=CssClass.TASKDETAIL,
q_a=q_a,
css_copyright=CssClass.COPYRIGHT,
)
return h
def get_task_html(self, req: CamcopsRequest) -> str:
main_dict = {
None: None,
1: "1 — " + self.wxstring(req, "wemwbs_a1"),
2: "2 — " + self.wxstring(req, "wemwbs_a2"),
3: "3 — " + self.wxstring(req, "wemwbs_a3"),
4: "4 — " + self.wxstring(req, "wemwbs_a4"),
5: "5 — " + self.wxstring(req, "wemwbs_a5"),
}
q_a = ""
for i in range(1, self.N_QUESTIONS + 1):
nstr = str(i)
q_a += tr_qa(
self.wxstring(req, "swemwbs_q" + nstr),
get_from_dict(main_dict, getattr(self, "q" + nstr)),
)
h = """
<div class="{CssClass.SUMMARY}">
<table class="{CssClass.SUMMARY}">
{tr_is_complete}
{total_score}
</table>
</div>
<div class="{CssClass.EXPLANATION}">
Ratings are over the last 2 weeks.
</div>
<table class="{CssClass.TASKDETAIL}">
<tr>
<th width="60%">Question</th>
<th width="40%">Answer</th>
</tr>
{q_a}
</table>
<div class="{CssClass.COPYRIGHT}">
SWEMWBS: from Stewart-Brown et al. (2009), <i>Health and
Quality of Life Outcomes</i> 7:15,
http://www.hqlo.com/content/7/1/15;
© 2009 Stewart-Brown et al.; distributed under the terms of the
Creative Commons Attribution License.
</div>
""".format(
CssClass=CssClass,
tr_is_complete=self.get_is_complete_tr(req),
total_score=tr(
req.sstring(SS.TOTAL_SCORE),
answer(self.total_score())
+ f" (range {self.MINTOTALSCORE}–{self.MAXTOTALSCORE})",
),
q_a=q_a,
)
return h
def get_task_html(self, req: CamcopsRequest) -> str:
main_dict = {
None: None,
0: "0 — " + self.wxstring(req, "old_option0"),
1: "1 — " + self.wxstring(req, "old_option1"),
2: "2 — " + self.wxstring(req, "old_option2"),
3: "3 — " + self.wxstring(req, "old_option3"),
4: "4 — " + self.wxstring(req, "old_option4"),
5: "5 — " + self.wxstring(req, "old_option5"),
6: "6 — " + self.wxstring(req, "old_option6"),
7: "7 — " + self.wxstring(req, "old_option7"),
}
q19_dict = {
None: None,
1: self.wxstring(req, "q19_option1"),
2: self.wxstring(req, "q19_option2"),
3: self.wxstring(req, "q19_option3"),
4: self.wxstring(req, "q19_option4"),
5: self.wxstring(req, "q19_option5"),
6: self.wxstring(req, "q19_option6"),
7: self.wxstring(req, "q19_option7"),
}
q20_dict = {
None: None,
0: self.wxstring(req, "q20_option0"),
1: self.wxstring(req, "q20_option1"),
2: self.wxstring(req, "q20_option2"),
3: self.wxstring(req, "q20_option3"),
4: self.wxstring(req, "q20_option4"),
5: self.wxstring(req, "q20_option5"),
6: self.wxstring(req, "q20_option6"),
7: self.wxstring(req, "q20_option7"),
}
q_a = ""
for i in range(1, Bprs.NQUESTIONS - 1): # only does 1-18
q_a += tr_qa(
self.wxstring(req, "q" + str(i) + "_title"),
get_from_dict(main_dict, getattr(self, "q" + str(i))),
)
q_a += tr_qa(self.wxstring(req, "q19_title"),
get_from_dict(q19_dict, self.q19))
q_a += tr_qa(self.wxstring(req, "q20_title"),
get_from_dict(q20_dict, self.q20))
total_score = tr(
req.sstring(SS.TOTAL_SCORE) +
f" (0–{self.MAX_SCORE}; 18–{self.MAX_SCORE} if all rated) "
"<sup>[1]</sup>",
answer(self.total_score()),
)
return f"""
def get_description(self, req: CamcopsRequest) -> str:
if self.meets_criteria_mania_psychotic_schizophrenic():
return self.wxstring(req, "category_manic_psychotic_schizophrenic")
elif self.meets_criteria_mania_psychotic_icd():
return self.wxstring(req, "category_manic_psychotic")
elif self.meets_criteria_mania_nonpsychotic():
return self.wxstring(req, "category_manic_nonpsychotic")
elif self.meets_criteria_hypomania():
return self.wxstring(req, "category_hypomanic")
elif self.meets_criteria_none():
return self.wxstring(req, "category_none")
else:
return req.sstring(SS.UNKNOWN)
def get_task_html(self, req: CamcopsRequest) -> str:
score = self.total_score()
severity = self.severity(req)
answer_dicts = []
for q in range(1, self.NQUESTIONS + 1):
d = {None: None}
for option in range(0, 5):
if q == 6 and option > 2:
continue
d[option] = self.wxstring(
req, "q" + str(q) + "_option" + str(option))
answer_dicts.append(d)
q_a = ""
for q in range(1, self.NQUESTIONS + 1):
q_a += tr_qa(
self.wxstring(req, "q" + str(q) + "_s"),
get_from_dict(answer_dicts[q - 1], getattr(self,
"q" + str(q))),
)
return """
<div class="{CssClass.SUMMARY}">
<table class="{CssClass.SUMMARY}">
{tr_is_complete}
{total_score}
{severity}
</table>
</div>
<table class="{CssClass.TASKDETAIL}">
<tr>
<th width="30%">Question</th>
<th width="70%">Answer</th>
</tr>
{q_a}
</table>
<div class="{CssClass.FOOTNOTES}">
[1] ≥20 severe, ≥12 moderate, ≥4 mild, <4 none.
</div>
""".format(
CssClass=CssClass,
tr_is_complete=self.get_is_complete_tr(req),
total_score=tr(
req.sstring(SS.TOTAL_SCORE),
answer(score) + " / {}".format(self.MAX_SCORE),
),
severity=tr_qa(
self.wxstring(req, "severity") + " <sup>[1]</sup>", severity),
q_a=q_a,
)
def get_task_html(self, req: CamcopsRequest) -> str:
score_dict = {
None: None,
0: "0 — " + self.wxstring(req, "a0"),
1: "1 — " + self.wxstring(req, "a1"),
2: "2 — " + self.wxstring(req, "a2"),
3: "3 — " + self.wxstring(req, "a3"),
}
rows = ""
for i in range(1, self.N_SCORED_QUESTIONS + 1):
q_field = "q" + str(i)
question_cell = "{}. {}".format(i, self.wxstring(req, q_field))
answer_cell = get_from_dict(score_dict, getattr(self, q_field))
rows += tr_qa(question_cell, answer_cell)
rows += tr_qa(
"16. " + self.wxstring(req, "q16"), get_yes_no_unknown(req, "q16")
)
html = """
<div class="{CssClass.SUMMARY}">
<table class="{CssClass.SUMMARY}">
{tr_is_complete}
{total_score}
</table>
</div>
<table class="{CssClass.TASKDETAIL}">
<tr>
<th width="60%">Question</th>
<th width="40%">Answer</th>
</tr>
{rows}
</table>
<div class="{CssClass.FOOTNOTES}">
[1] Sum for questions 1–15.
</div>
""".format(
CssClass=CssClass,
tr_is_complete=self.get_is_complete_tr(req),
total_score=tr(
req.sstring(SS.TOTAL_SCORE) + " <sup>[1]</sup>",
answer(self.total_score()) + f" / {self.MAX_SCORE_MAIN}",
),
rows=rows,
)
return html
def get_answer(self, req: CamcopsRequest, q: int) -> Optional[str]:
qstr = str(q)
value = getattr(self, "q" + qstr)
if value is None:
return None
prefix = "q" + qstr + "_a_"
if value == ALWAYS:
return self.wxstring(req, prefix + "always")
if value == SOMETIMES:
return self.wxstring(req, prefix + "sometimes")
if value == NEVER:
return self.wxstring(req, prefix + "never")
if value == NA:
if q in SPECIAL_NA_TEXT_QUESTIONS:
return self.wxstring(req, prefix + "na")
return req.sstring(SS.NA)
return None
def get_task_html(self, req: CamcopsRequest) -> str:
return """
{clinician_comments}
<div class="{CssClass.SUMMARY}">
<table class="{CssClass.SUMMARY}">
{tr_is_complete}
{date_pertains_to}
{meets_criteria}
</table>
</div>
<div class="{CssClass.EXPLANATION}">
{icd10_symptomatic_disclaimer}
</div>
<table class="{CssClass.TASKDETAIL}">
<tr>
<th width="80%">Question</th>
<th width="20%">Answer</th>
</tr>
{mixture_or_rapid_alternation}
{duration_at_least_2_weeks}
</table>
{ICD10_COPYRIGHT_DIV}
""".format(
clinician_comments=self.get_standard_clinician_comments_block(
req, self.comments),
CssClass=CssClass,
tr_is_complete=self.get_is_complete_tr(req),
date_pertains_to=tr_qa(
req.wappstring(AS.DATE_PERTAINS_TO),
format_datetime(self.date_pertains_to,
DateFormat.LONG_DATE,
default=None),
),
meets_criteria=tr_qa(
req.sstring(SS.MEETS_CRITERIA),
get_true_false_none(req, self.meets_criteria()),
),
icd10_symptomatic_disclaimer=req.wappstring(
AS.ICD10_SYMPTOMATIC_DISCLAIMER),
mixture_or_rapid_alternation=self.get_twocol_bool_row_true_false(
req, "mixture_or_rapid_alternation", self.wxstring(req, "a")),
duration_at_least_2_weeks=self.get_twocol_bool_row_true_false(
req, "duration_at_least_2_weeks", self.wxstring(req, "b")),
ICD10_COPYRIGHT_DIV=ICD10_COPYRIGHT_DIV,
)
def get_task_html(self, req: CamcopsRequest) -> str:
score = self.total_score()
exceeds_cutoff = score >= 2
q_a = ""
for q in range(1, Cage.NQUESTIONS + 1):
q_a += tr_qa(
str(q) + " — " + self.wxstring(req, "q" + str(q)),
getattr(self, "q" + str(q)),
) # answer is itself Y/N/NULL # noqa
total_score = tr(
req.sstring(SS.TOTAL_SCORE),
answer(score) + f" / {self.NQUESTIONS}",
)
over_threshold = tr_qa(
self.wxstring(req, "over_threshold"),
get_yes_no(req, exceeds_cutoff),
)
return f"""
def get_task_html(self, req: CamcopsRequest) -> str:
q_a = self.text_row(req, "a")
for i in range(1, self.N_A + 1):
q_a += self.get_twocol_bool_row_true_false(
req, "a" + str(i), self.wxstring(req, "a" + str(i)))
q_a += self.get_twocol_bool_row_true_false(req, "b",
self.wxstring(req, "b"))
h = """
{clinician_comments}
<div class="{CssClass.SUMMARY}">
<table class="{CssClass.SUMMARY}">
{tr_is_complete}
{date_pertains_to}
{meets_criteria}
</table>
</div>
<table class="{CssClass.TASKDETAIL}">
<tr>
<th width="80%">Question</th>
<th width="20%">Answer</th>
</tr>
{q_a}
</table>
{ICD10_COPYRIGHT_DIV}
""".format(
clinician_comments=self.get_standard_clinician_comments_block(
req, self.comments),
CssClass=CssClass,
tr_is_complete=self.get_is_complete_tr(req),
date_pertains_to=tr_qa(
req.wappstring(AS.DATE_PERTAINS_TO),
format_datetime(self.date_pertains_to,
DateFormat.LONG_DATE,
default=None),
),
meets_criteria=tr_qa(
req.sstring(SS.MEETS_CRITERIA),
get_yes_no_none(req, self.meets_criteria()),
),
q_a=q_a,
ICD10_COPYRIGHT_DIV=ICD10_COPYRIGHT_DIV,
)
return h
def get_main_description(self, req: CamcopsRequest) -> str:
if self.meets_criteria_severe_psychotic_schizophrenic():
return self.wxstring(req,
"category_severe_psychotic_schizophrenic")
elif self.meets_criteria_severe_psychotic_icd():
return self.wxstring(req, "category_severe_psychotic")
elif self.meets_criteria_severe_nonpsychotic():
return self.wxstring(req, "category_severe_nonpsychotic")
elif self.meets_criteria_moderate():
return self.wxstring(req, "category_moderate")
elif self.meets_criteria_mild():
return self.wxstring(req, "category_mild")
elif self.meets_criteria_none():
return self.wxstring(req, "category_none")
else:
return req.sstring(SS.UNKNOWN)
def get_task_html(self, req: CamcopsRequest) -> str:
answers = {
None: None,
0: "0 — " + self.wxstring(req, "a0"),
1: "1 — " + self.wxstring(req, "a1"),
2: "2 — " + self.wxstring(req, "a2"),
3: "3 — " + self.wxstring(req, "a3"),
4: "4 — " + self.wxstring(req, "a4"),
}
subscore_html = ""
answer_html = ""
for info in self.GROUPS:
heading = self.wxstring(req, info.heading_xstring_name)
subscore = info.subscore(self)
subscore_html += tr(
heading,
(answer(round(subscore, DISPLAY_DP)) + f" / {info.max_score}"),
)
answer_html += subheading_spanning_two_columns(heading)
for q in info.fieldnames:
if q == self.OPTIONAL_Q:
# insert additional row
answer_html += tr_qa(self.xstring(req, "prefer_no_answer"),
self.ignore_s_q7)
answer_val = getattr(self, q)
answer_html += tr_qa(self.wxstring(req, q),
get_from_dict(answers, answer_val))
tscore = round(self.total_score(), DISPLAY_DP)
tr_total_score = tr(
req.sstring(SS.TOTAL_SCORE),
answer(tscore) + f" / {self.MAX_SCORE_TOTAL}",
)
return f"""
def get_trackers(self, req: CamcopsRequest) -> List[TrackerInfo]:
if self.highschooleducation == 1:
hlines = [26.5, 20.5]
y_upper = 28.25
y_middle = 23.5
else:
hlines = [24.5, 19.5]
y_upper = 27.25
y_middle = 22
return [
TrackerInfo(
value=self.total_score(),
plot_label="SLUMS total score",
axis_label=f"Total score (out of {self.MAX_SCORE})",
axis_min=-0.5,
axis_max=self.MAX_SCORE + 0.5,
horizontal_lines=hlines,
horizontal_labels=[
TrackerLabel(y_upper, req.sstring(SS.NORMAL)),
TrackerLabel(y_middle, self.wxstring(req, "category_mci")),
TrackerLabel(17, self.wxstring(req, "category_dementia")),
],
)
]
def get_task_html(self, req: CamcopsRequest) -> str:
def loadvalues(_dict: Dict[int, str], _first: int, _last: int,
_xstringprefix: str) -> None:
for val in range(_first, _last + 1):
_dict[
val] = f"{val} — {self.wxstring(req, f'{_xstringprefix}{val}')}"
respondent_dict = {} # type: Dict[int, str]
loadvalues(
respondent_dict,
self.VAL_QA_PATIENT,
self.VAL_QA_PARTNER_OTHER,
"qa_a",
)
service_dict = {} # type: Dict[int, str]
loadvalues(service_dict, self.VAL_QB_INPATIENT, self.VAL_QB_COMMUNITY,
"qb_a")
mh_dict = {} # type: Dict[int, str]
loadvalues(
mh_dict,
self.VAL_Q1_VERY_WELL,
self.VAL_Q1_EXTREMELY_UNWELL,
"q1_a",
)
agree_dict = {} # type: Dict[int, str]
loadvalues(
agree_dict,
self.VAL_STRONGLY_AGREE,
self.VAL_STRONGLY_DISAGREE,
"agreement_a",
)
q_a_list = [] # type: List[str]
def addqa(_fieldname: str, _valuedict: Dict[int, str]) -> None:
xstringname = _fieldname + "_q"
q_a_list.append(
tr_qa(
self.xstring(req, xstringname), # not wxstring
get_from_dict(_valuedict, getattr(self, _fieldname)),
))
def subheading(_xstringname: str) -> None:
q_a_list.append(
subheading_spanning_two_columns(
self.wxstring(req, _xstringname)))
# Preamble
addqa(self.FN_QA_RESPONDENT, respondent_dict)
addqa(self.FN_QB_SERVICE_TYPE, service_dict)
# The bulk
subheading("q1_stem")
for fieldname in self.Q1_FIELDS:
addqa(fieldname, mh_dict)
subheading("q2_stem")
for fieldname in self.Q2_FIELDS:
addqa(fieldname, agree_dict)
if self.was_inpatient():
subheading("q3_stem")
for fieldname in self.Q3_FIELDS:
addqa(fieldname, agree_dict)
# General
q_a_list.append(
subheading_spanning_two_columns(req.sstring(SS.GENERAL)))
q_a_list.append(
tr_qa(self.wxstring(req, "general_comments_q"),
self.general_comments))
q_a_list.append(
tr_qa(
self.wxstring(req, "participation_q"),
get_yes_no_none(req, self.future_participation),
))
if self.offering_participation():
q_a_list.append(
tr_qa(
self.wxstring(req, "contact_details_q"),
self.contact_details,
))
q_a = "\n".join(q_a_list)
return f"""