class XlListTask(ExecutionTask):
sViewCountFull = AnfisaConfig.configOption("xl.view.count.full")
sViewCountSamples = AnfisaConfig.configOption("xl.view.count.samples")
sViewMinSamples = AnfisaConfig.configOption("xl.view.min.samples")
def __init__(self, dataset, condition):
ExecutionTask.__init__(self, "Prepare variants...")
self.mDS = dataset
self.mCondition = condition
def execIt(self):
rec_no_seq = self.mDS.evalSampleList(self.mCondition,
self.sViewCountFull + 5)
if len(rec_no_seq) > self.sViewCountFull:
rec_no_seq = rec_no_seq[:self.sViewCountSamples]
q_samples, q_full = True, False
elif len(rec_no_seq) <= self.sViewMinSamples:
q_samples, q_full = False, True
else:
q_samples, q_full = True, True
total = self.mDS.getTotal()
step_cnt = total // 100
cur_progress = 0
next_cnt = step_cnt
self.setStatus("Preparation progress: 0%")
rec_no_dict = {rec_no: None for rec_no in rec_no_seq}
with self.mDS._openPData() as inp:
pdata_inp = TextIOWrapper(inp,
encoding="utf-8",
line_buffering=True)
for rec_no, line in enumerate(pdata_inp):
if rec_no > next_cnt:
next_cnt += step_cnt
cur_progress += 1
self.setStatus("Preparation progress: %d%s" %
(min(cur_progress, 100), '%'))
if rec_no not in rec_no_dict:
continue
pre_data = json.loads(line.strip())
rec_no_dict[rec_no] = [
rec_no,
escape(pre_data.get("_label")),
AnfisaConfig.normalizeColorCode(pre_data.get("_color"))
]
self.setStatus("Finishing")
ret = dict()
if q_samples:
ret["samples"] = [
rec_no_dict[rec_no]
for rec_no in rec_no_seq[:self.sViewCountSamples]
]
if q_full:
ret["records"] = [
rec_no_dict[rec_no] for rec_no in sorted(rec_no_seq)
]
self.setStatus("Done")
return ret
def reportRecord(output, ds_h, rec_no, details=None, port=-1):
css_files = ["rec.css", "base.css"]
js_files = ["rec.js", "base.js"]
use_tags = "false"
if ds_h.getDSKind() == "ws" and port >= 0:
css_files.append("tags.css")
js_files.append("tags.js")
use_tags = "true"
else:
assert port < 1
startHtmlPage(output, css_files=css_files, js_files=js_files)
print('<body onload="init_r(%d, \'%s\', %d, %s, \'%s\');">' %
(port, ds_h.getLastAspectID() if port == 1 else
ds_h.getFirstAspectID(), rec_no, use_tags, ds_h.getName()),
file=output)
print('<div id="r-tab">', file=output)
print(
'<span id="img-wrap" onclick="tabCfgChange();">'
'<img id="img-tab2" src="ui/images/tab2-exp.png"/></span>',
file=output)
asp_data_seq = ds_h.getViewRepr(rec_no, details)
for asp_data in asp_data_seq:
print('<button class="r-tablnk %s" id="la--%s" '
'onclick="pickAspect(\'%s\')">%s</button>' %
(asp_data["kind"], asp_data["name"], asp_data["name"],
AnfisaConfig.decorText(asp_data["title"])),
file=output)
if use_tags == "true":
tags_asp_name = AnfisaConfig.configOption("aspect.tags.name")
print('<button class="r-tablnk %s" id="la--%s" '
'onclick="pickAspect(\'%s\')">%s</button>' %
("tech", tags_asp_name, tags_asp_name,
AnfisaConfig.textMessage("aspect.tags.title")),
file=output)
print('</div>', file=output)
print('<div id="r-cnt-container">', file=output)
for asp_data in asp_data_seq:
print('<div id="a--%s" class="r-tabcnt">' % asp_data["name"],
file=output)
_reportAspect(output, asp_data)
print('</div>', file=output)
if use_tags == "true":
print(('<div id="a--%s" class="r-tabcnt">' % tags_asp_name),
file=output)
tagsBlock(output)
print('</div>', file=output)
print('</div>', file=output)
print('</body>', file=output)
print('</html>', file=output)
def reportWsRecord(output, workspace, research_mode, rec_no, details, port):
startHtmlPage(output,
css_files=["base.css", "a_rec.css", "tags.css"],
js_files=["a_rec.js", "tags.js", "base.js"])
if port == "2":
print('<body onload="init_r(2, \'%s\');">' %
workspace.getFirstAspectID(),
file=output)
elif port == "1":
print('<body onload="init_r(1, \'%s\');">' %
workspace.getLastAspectID(),
file=output)
else:
print('<body onload="init_r(0, \'%s\', \'%s\', %d);">' %
(workspace.getFirstAspectID(), workspace.getName(), rec_no),
file=output)
print('<div class="r-tab">', file=output)
print(
'<span id="img-wrap" onclick="tabCfgChange();">'
'<img id="img-tab2" src="ui/images/tab2-exp.png"/></span>',
file=output)
asp_data_seq = workspace.getViewRepr(rec_no, research_mode, details)
for asp_data in asp_data_seq:
print('<button class="r-tablnk %s" id="la--%s" '
'onclick="pickAspect(\'%s\')">%s</button>' %
(asp_data["kind"], asp_data["name"], asp_data["name"],
AnfisaConfig.decorText(asp_data["title"])),
file=output)
tags_asp_name = AnfisaConfig.configOption("aspect.tags.name")
print('<button class="r-tablnk %s" id="la--%s" '
'onclick="pickAspect(\'%s\')">%s</button>' %
("tech", tags_asp_name, tags_asp_name,
AnfisaConfig.textMessage("aspect.tags.title")),
file=output)
print('</div>', file=output)
print('<div id="r-cnt-container">', file=output)
for asp_data in asp_data_seq:
print('<div id="a--%s" class="r-tabcnt">' % asp_data["name"],
file=output)
_reportAspect(output, asp_data)
print('</div>', file=output)
print(('<div id="a--%s" class="r-tabcnt">' % tags_asp_name), file=output)
tagsBlock(output)
print('</div>', file=output)
print('</div>', file=output)
print('</body>', file=output)
print('</html>', file=output)
def selectionTagging(self, tag_name, rec_no_seq):
assert tag_name and tag_name not in self.mCheckTags, ("Missing tag: " +
tag_name)
new_tag_keys = {
self.getDS().getRecKey(rec_no)
for rec_no in rec_no_seq
}
to_update_seq = []
for tags_info in self.getDS().getSolEnv().iterEntries("tags"):
rec_key, tags_data = tags_info[:2]
if tags_data is None:
continue
if rec_key in new_tag_keys:
new_tag_keys.remove(rec_key)
tags_data = deepcopy(tags_data)
tags_data[tag_name] = "True"
to_update_seq.append((rec_key, tags_data))
elif tag_name in tags_data:
tags_data = deepcopy(tags_data)
del tags_data[tag_name]
to_update_seq.append((rec_key, tags_data))
simple_tag_data = {tag_name: "True"}
max_tag_name_length = AnfisaConfig.configOption("tag.name.max.length")
for rec_key in new_tag_keys:
assert len(rec_key) <= max_tag_name_length, (
"Too long tag name (%d+): %s" % (max_tag_name_length, rec_key))
to_update_seq.append((rec_key, simple_tag_data))
for rec_key, tags_data in to_update_seq:
self.getDS().getSolEnv().modifyEntry(self.getDS().getName(),
"tags", "UPDATE", rec_key,
tags_data)
def reportXlRecord(output, dataset, rec_no):
startHtmlPage(output,
css_files=["base.css", "a_rec.css"],
js_files=["xl_rec.js"])
print('<body onload="init_r(\'%s\', \'%s\', %d);">' %
(dataset.getFirstAspectID(), dataset.getName(), rec_no),
file=output)
print('<div class="r-tab">', file=output)
print(
'<span id="img-wrap" onclick="tabCfgChange();">'
'<img id="img-tab2" src="ui/images/tab2-exp.png"/></span>',
file=output)
asp_data_seq = dataset.getViewRepr(rec_no, True)
for asp_data in asp_data_seq:
print('<button class="r-tablnk %s" id="la--%s" '
'onclick="pickAspect(\'%s\')">%s</button>' %
(asp_data["kind"], asp_data["name"], asp_data["name"],
AnfisaConfig.decorText(asp_data["title"])),
file=output)
print('</div>', file=output)
print('<div id="r-cnt-container">', file=output)
for asp_data in asp_data_seq:
print('<div id="a--%s" class="r-tabcnt">' % asp_data["name"],
file=output)
_reportAspect(output, asp_data)
print('</div>', file=output)
print('</div>', file=output)
print('</div>', file=output)
print('</body>', file=output)
print('</html>', file=output)
def __init__(self, flt_schema, sol_broker, hard_check):
self.mHardCheck = hard_check
self.mConvertors = []
self.mTotalItemCount = 0
self.mTransPathBaseF = AttrFuncPool.makeFunc(
AnfisaConfig.configOption("transcript.path.base"))
self.mUnitStatSeq = []
panels_convertors = []
for unit_descr in flt_schema:
kind, sub_kind = unit_descr["kind"], unit_descr["sub-kind"]
if kind == "numeric":
if sub_kind.startswith("transcript-"):
self.mConvertors.append(TrNumConvertor(unit_descr))
else:
self.mUnitStatSeq.append(NumUnitStatH(unit_descr))
elif kind == "enum":
if sub_kind == "transcript-status":
self.mConvertors.append(
TrStatusConvertor(unit_descr))
elif sub_kind == "transcript-multiset":
self.mConvertors.append(
TrMultisetConvertor(unit_descr))
elif sub_kind == "transcript-panels":
panels_convertors.append(
TrPanelsConvertor(sol_broker, unit_descr))
else:
self.mUnitStatSeq.append(EnumUnitStatH(unit_descr))
else:
assert False, "Bad kind:" + unit_descr["kind"]
self.mConvertors += panels_convertors
def modifyData(self, option, name, value, upd_from):
if option == "UPDATE":
time_label = datetime.now().isoformat()
self.mMongoAgent.update_one({
"_tp": self.mSolKind,
"name": name
}, {
"$set": {
self.mSolKind: value,
"_tp": self.mSolKind,
"time": time_label,
"from": upd_from
}
},
upsert=True)
self.mData[name] = [
value, AnfisaConfig.normalizeTime(time_label), upd_from
]
self.mIntVersion += 1
return True
if option == "DELETE" and name in self.mData:
self.mMongoAgent.delete_many({"_tp": self.mSolKind, "name": name})
del self.mData[name]
self.mIntVersion += 1
return True
return False
def __init__(self, ds_h, ws_name, eval_h, force_mode = False):
ExecutionTask.__init__(self, "Secondary WS creation")
self.mDS = ds_h
self.mWSName = ws_name
self.mEval = eval_h
self.mReportLines = AnfisaConfig.configOption("report.lines")
self.mForceMode = force_mode
def execIt(self):
while True:
with self.mDS:
if len(self.mNextPointIdxs) == 0:
break
idx = self.mNextPointIdxs[0]
try:
with self.mCondition:
self.mCondition.notify_all()
counts = self.mDS.getEvalSpace().evalTotalCounts(
self.mDTreeH.getActualCondition(idx))
except Exception as err:
logException("Long run exception in DS=%s" %
self.mDS.getName())
self.mFailureCount += 1
if self.mFailureCount > AnfisaConfig.configOption(
"long.run.failures"):
raise err
else:
continue
with self.mDS:
self.mTimeAccess = datetime.now()
self.mCounts[idx] = counts
if counts[0] == 0 and self.mDTreeH.checkZeroAfter(idx):
for idx1 in range(idx, len(self.mCounts)):
self.mCounts[idx1] = counts[:]
for j, pcounts in enumerate(self.mCounts):
if pcounts is not None and j in self.mNextPointIdxs:
self.mNextPointIdxs.remove(j)
with self.mDS:
with self.mCondition:
self.mCondition.notify_all()
self.mCondition = None
return False
def rq__xl_export(self, rq_args):
_, condition = self._prepareConditions(rq_args)
rec_count = self.evalTotalCount(condition)
assert rec_count <= AnfisaConfig.configOption("max.export.size")
rec_no_seq = self.evalRecSeq(condition, rec_count)
fname = self.getApp().makeExcelExport(
self.getName(), self, rec_no_seq)
return {"kind": "excel", "fname": fname}
def _getRecData(self, rec_no):
rec_key = self.getWS().getRecKey(rec_no)
rec_data = self.getWS().getMongoRecData(rec_key)
if rec_data is None:
return (dict(), None, None)
return (dict(filter(self._goodPair,
rec_data.items())), rec_data.get('_h'),
AnfisaConfig.normalizeTime(rec_data.get('_t')))
def getFilters(self):
ret = []
for it in self.mAgent.find({"_tp": "flt"}):
it_id = it["_id"]
if it_id.startswith("flt-"):
ret.append((it_id[4:], it["seq"],
AnfisaConfig.normalizeTime(it.get("time"))))
return ret
def __init__(self, data_vault, dataset_info, dataset_path):
DataSet.__init__(self,
data_vault,
dataset_info,
dataset_path,
add_modes={"WS"})
assert self.getRecStorage().getKind() == "disk", (
"Missing storage kind: " + self.getRecStorage().getKind())
self.mTabRecRand = array('q')
self.mTabRecKey = []
self.mTabRecColor = []
self.mTabRecLabel = []
self.mKey2Idx = None
self.mEvalSpace = WS_EvalSpace(
self, self._makeRecArrayFunc(self.mTabRecRand))
self.mZygArrays = []
for zyg_name in self.getZygUnitNames():
var_array = array('b')
self.mZygArrays.append(var_array)
self.mEvalSpace._addZygUnit(zyg_name,
self._makeRecArrayFunc(var_array))
transcript_id_unit = None
for unit_data in self.getFltSchema():
unit_h = loadWS_Unit(self.mEvalSpace, unit_data)
if unit_h is not None:
self.mEvalSpace._addUnit(unit_h)
if unit_h.isTranscriptID() and transcript_id_unit is None:
transcript_id_unit = unit_h.getName()
self._loadPData()
self._loadFData()
self.mTagsMan = TagsManager(
self, self.getPanelVariants("Check-Tags", "_tags"))
self.mRulesUnit = RulesUnit(self)
self.mEvalSpace._insertUnit(self.mRulesUnit, insert_idx=0)
if not transcript_id_unit:
transcript_id_unit = AnfisaConfig.configOption("ws.transcript.id")
self.mEvalSpace._setupTrIdUnit(transcript_id_unit)
self.startService()
self.mZoneHandlers = []
for zone_it in self.iterStdItems("zone"):
unit_name = zone_it.getData()
if (unit_name == "_tags"):
zone_h = self.mTagsMan
zone_h._setTitle(zone_it.getName())
else:
unit_h = self.mEvalSpace.getUnit(unit_name)
if (not unit_h):
continue
zone_h = FilterZoneH(self, zone_it.getName(), unit_h)
self.mZoneHandlers.append(zone_h)
for filter_h in self.iterSolEntries("filter"):
filter_h.activate()
for dtree_h in self.iterSolEntries("dtree"):
dtree_h.activate()
def reportRecord(self, rec_no, rec_it_map=None, marked_set=None):
ret = {
"no": rec_no,
"lb": escape(self.mTabRecLabel[rec_no]),
"cl": AnfisaConfig.normalizeColorCode(self.mTabRecColor[rec_no])
}
if rec_it_map is not None:
ret["dt"] = rec_it_map.to01()
return ret
def __init__(self, ds_h, descr):
FunctionUnit.__init__(self,
ds_h.getEvalSpace(),
descr,
sub_kind="comp-hets",
parameters=["approx", "state"])
self.mZygSupport = ds_h.getZygositySupport()
self.mOpCache = LRUCache(
AnfisaConfig.configOption("comp-hets.cache.size"))
def _reportListKeys(self, rec_no_seq, rec_it_map_seq):
marked_set = self.mTagsMan.getMarkedSet()
ret = []
for idx, rec_no in enumerate(rec_no_seq):
ret.append([
rec_no,
escape(self.mTabRecLabel[rec_no]),
AnfisaConfig.normalizeColorCode(self.mTabRecColor[rec_no]),
rec_no in marked_set, rec_it_map_seq[idx].to01()
])
return ret
def __init__(self, sol_kind, mongo_agent):
self.mSolKind = sol_kind
self.mMongoAgent = mongo_agent
self.mData = dict()
self.mIntVersion = 0
for it in self.mMongoAgent.find({"_tp": self.mSolKind}):
name = it["name"]
self.mData[name] = [
it[self.mSolKind],
AnfisaConfig.normalizeTime(it.get("time")), it["from"]
]
def reportList(self, rec_no_seq, rec_it_map_seq, counts_transctipts,
random_mode):
rep = {
"workspace": self.getName(),
"total": self.getTotal(),
"transcripts": counts_transctipts,
"filtered": len(rec_no_seq)
}
if (random_mode and
len(rec_no_seq) > AnfisaConfig.configOption("rand.min.size")):
sheet = [(self.mTabRecRand[rec_no], idx)
for idx, rec_no in enumerate(rec_no_seq)]
sheet.sort()
del sheet[AnfisaConfig.configOption("rand.sample.size"):]
rec_no_seq = [rec_no_seq[idx] for _, idx in sheet]
rec_it_map_seq = [rec_it_map_seq[idx] for _, idx in sheet]
rep["list-mode"] = "samples"
else:
rep["list-mode"] = "complete"
rep["records"] = self._reportListKeys(rec_no_seq, rec_it_map_seq)
return rep
def __init__(self, ds_h, descr):
FunctionUnit.__init__(self,
ds_h.getEvalSpace(),
descr,
sub_kind="inheritance-z",
parameters=["problem_group"])
assert ds_h.testRequirements({"ZYG"})
self.mZygSupport = ds_h.getZygositySupport()
self.mAvailLabels = self.sCaseLabels[:]
if not self.mZygSupport.hasXLinked():
self.mAvailLabels.remove(
AnfisaConfig.configOption("zygosity.cases")["x_linked"])
def rq__csv_export(self, rq_args):
eval_h = self._getArgCondFilter(rq_args)
rec_count = self.getEvalSpace().evalTotalCounts(
eval_h.getCondition())[0]
assert rec_count <= AnfisaConfig.configOption("max.export.size")
rec_no_seq = self.getEvalSpace().evalRecSeq(eval_h.getCondition(),
rec_count)
tab_schema = self.getStdItem("tab-schema", rq_args["schema"]).getData()
return [
"!", "csv",
reportCSV(self, tab_schema, rec_no_seq),
[("Content-Disposition", "attachment;filename=anfisa_export.csv")]
]
def _addVersion(self, tree_code, tree_hash, version_info_seq):
new_ver_no = 0
if len(version_info_seq) > 0:
ver_no, ver_data, ver_hash = version_info_seq[-1]
if ver_hash == tree_hash:
return version_info_seq
new_ver_no = ver_no + 1
self.getMongoAgent().addTreeCodeVersion(
new_ver_no, tree_code, tree_hash)
while (len(version_info_seq) + 1 >
AnfisaConfig.configOption("max.tree.versions")):
self.getMongoAgent().dropTreeCodeVersion(version_info_seq[0][0])
del version_info_seq[0]
return self.getMongoAgent().getTreeCodeVersions()
def saveRecord(self, record):
rec_no = self.mTotal
flt_data = self.mFilterSet.process(rec_no, record)
if self.mViewChecker is not None:
self.mViewChecker.regValue(rec_no, record)
pre_data = AnfisaConfig.getVariantSystemFields(record)
self.mTransPrep.doRec(rec_no, record, flt_data, pre_data)
if self.mVDataProc is not None:
print(json.dumps(record, ensure_ascii=False), file=self.mVDataOut)
else:
self.mVDataOut.putLine(json.dumps(record, ensure_ascii=False))
print(json.dumps(flt_data, ensure_ascii=False), file=self.mFDataOut)
print(json.dumps(pre_data, ensure_ascii=False), file=self.mPDataOut)
self.mTotal += 1
def setup(cls, config, in_container):
setupSolutions(config)
cls.sConfig = config
MirrorUiDirectory.setup(cls.sConfig.get("mirror-ui"))
IntUI.setup(config, in_container)
cls.sDocReportCSS = MirrorUiDirectory.transform(
cls.sConfig["doc-report-css"])
cls.sDocPygmentsCSS = MirrorUiDirectory.transform(
cls.sConfig["doc-pygments-css"])
cls.sMongoConn = MongoConnector(cls.sConfig["mongo-db"],
cls.sConfig.get("mongo-host"), cls.sConfig.get("mongo-port"))
cls.sDruidAgent = DruidAgent(cls.sConfig)
cls.sDataVault = DataVault(cls, cls.sConfig["data-vault"],
anfisaVariables)
cls.sJobPool = JobPool(
AnfisaConfig.configOption("job.pool.threads"),
AnfisaConfig.configOption("job.pool.size"),
AnfisaConfig.configOption("job.pool.memlen"))
cls.sJobPool.addPeriodicalWorker("vault_update",
cls.sDataVault.scanAll,
float(cls.sConfig.get("job-vault-check-period", 30)))
sphinx_docs_seq = cls.sConfig.get("sphinx-doc-sets")
if sphinx_docs_seq:
for sphinx_docs_info in sphinx_docs_seq:
cls.sDocSets.append(SphinxDocumentationSet(sphinx_docs_info))
signal.signal(signal.SIGTERM, terminateAll)
signal.signal(signal.SIGHUP, terminateAll)
signal.signal(signal.SIGINT, terminateAll)
def __init__(self, data_vault, dataset_info, dataset_path):
DataSet.__init__(self, data_vault, dataset_info, dataset_path)
self.mTabRecRand = []
self.mTabRecKey = []
self.mTabRecColor = []
self.mTabRecLabel = []
self.mIndex = Index(self)
self._loadPData()
self.mTagsMan = TagsManager(self,
AnfisaConfig.configOption("check.tags"))
self.mIndex.setup()
for filter_name, cond_seq, time_label in \
self.getMongoAgent().getFilters():
if self.mIndex.goodOpFilterName(filter_name):
if not self.mIndex.cacheFilter(
filter_name,
ConditionMaker.upgradeOldFormatSeq(cond_seq),
time_label):
logging.error("Filter %s for ws=%s failed" %
(filter_name, self.getName()))
self.mZoneHandlers = []
for zone_title, unit_name in AnfisaConfig.configOption("zones"):
if (unit_name == "_tags"):
zone_h = self.mTagsMan
zone_h._setTitle(zone_title)
else:
unit = self.mIndex.getUnit(unit_name)
if (not unit):
continue
zone_h = FilterZoneH(self, zone_title, unit)
self.mZoneHandlers.append(zone_h)
self._setAspectHitGroup(
*AnfisaConfig.configOption("transcript.view.setup"))
def __init__(self,
dataset,
ws_name,
base_version=None,
op_cond=None,
std_name=None,
markup_batch=None,
force_mode=False):
ExecutionTask.__init__(self, "Secondary WS creation")
self.mDS = dataset
self.mWSName = ws_name
self.mBaseVersion = base_version
self.mOpCond = op_cond
self.mStdName = std_name
self.mMarkupBatch = markup_batch
self.mReportLines = AnfisaConfig.configOption("report.lines")
self.mForceMode = force_mode
def __init__(self,
data_vault,
dataset_info,
dataset_path,
sol_pack_name=None):
SolutionBroker.__init__(
self, dataset_info["meta"].get("data_schema", "CASE"),
dataset_info.get("modes"))
self.addModes(data_vault.getApp().getRunModes())
self.mDataVault = data_vault
self.mDataInfo = dataset_info
self.mName = dataset_info["name"]
self.mDSKind = dataset_info["kind"]
self.mTotal = dataset_info["total"]
self.mMongoAgent = (data_vault.getApp().getMongoConnector().getDSAgent(
dataset_info["mongo"], dataset_info["kind"]))
self.mAspects = AspectSetH.load(dataset_info["view_schema"])
self.mFltSchema = dataset_info["flt_schema"]
self.mPath = dataset_path
self.mFInfo = self.mDataVault.checkFileStat(self.mPath +
"/dsinfo.json")
if self.getDataSchema() == "FAVOR" and self.mDSKind == "xl":
self.mRecStorage = FavorStorage(
self.getApp().getOption("favor-url"))
else:
self.mRecStorage = DataDiskStorage(self, self.mPath)
self.mFamilyInfo = FamilyInfo(dataset_info["meta"])
if (self.mDataInfo.get("zygosity_var")
and 1 < len(self.mFamilyInfo) <= 10):
self.addModes({"ZYG"})
self.mZygSupport = None
self.mViewContext = dict()
if self.mFamilyInfo.getCohortList():
self.mViewContext["cohorts"] = self.mFamilyInfo.getCohortMap()
view_aspect = AnfisaConfig.configOption("view.cohorts.aspect")
self.mAspects[view_aspect]._setViewColMode("cohorts")
completeDsModes(self)
tuneAspects(self, self.mAspects)
def __init__(self, family_info, cond_env, descr):
ComplexEnumSupport.__init__(self)
self.mFamilyInfo = family_info
self.mCondEnv = cond_env
self.mIsOK = (self.mFamilyInfo is not None
and len(self.mFamilyInfo) > 1)
labels = AnfisaConfig.configOption("zygosity.cases")
self.mCaseLabels = [
labels[key]
for key in ("homo_recess", "x_linked", "dominant", "compens")
]
self.mVariantSet = VariantSet(self.mCaseLabels)
self.mConfig = descr.get("config", dict())
self.mXCondition = None
self.mFamNames = [
"%s_%d" % (descr["name"], idx)
for idx in range(len(self.mFamilyInfo))
]
self.mFamUnits = None
assert ("size" not in descr or descr["size"] == len(self.mFamilyInfo))
def __init__(self, flt_schema, hard_check):
self.mHardCheck = hard_check
self.mConvertors = []
self.mTotalItemCount = 0
self.mTransPathBaseF = AttrFuncPool.makeFunc(
AnfisaConfig.configOption("transcript.path.base"))
self.mUnitStatSeq = []
for unit_descr in flt_schema:
kind = unit_descr["kind"]
if not kind.startswith("transcript-"):
if kind in ("long", "float"):
self.mUnitStatSeq.append(NumUnitStatH(unit_descr))
elif kind == "enum":
self.mUnitStatSeq.append(EnumUnitStatH(unit_descr))
continue
if kind == "transcript-status":
self.mConvertors.append(TrStatusConvertor(unit_descr))
elif kind == "transcript-multiset":
self.mConvertors.append(TrMultisetConvertor(unit_descr))
else:
assert False, "Bad kind:" + unit_descr["kind"]
def collectRecSeq(self):
max_ws_size = AnfisaConfig.configOption("max.ws.size")
html_lines = self._decorCode()
ret = set()
info_seq = []
for point in self.mPointList:
info_seq.append([point.getCodeFrag(html_lines), None, None])
if not point.isActive():
continue
condition = point.actualCondition()
point_count = self.getEvalSpace().evalTotalCounts(condition)[0]
info_seq[-1][1] = point_count
if point.getPointKind() == "Return":
info_seq[-1][2] = point.getDecision()
if point.getDecision() is True:
assert point.getPointKind() == "Return"
assert point_count < max_ws_size
if point_count > 0:
seq = self.getEvalSpace().evalRecSeq(
condition, point_count)
ret |= set(seq)
assert len(ret) < max_ws_size
return sorted(ret), info_seq
def collectRecSeq(self, dataset):
max_ws_size = AnfisaConfig.configOption("max.ws.size")
ret = set()
info_seq = []
html_lines = htmlCodePresentation(self.mCode)
for point in self.mPointList:
info_seq.append([point.getCodeFrag(html_lines), None, None])
if not point.isActive:
continue
condition = point.actualCondition()
point_count = dataset.evalTotalCount(condition)
info_seq[-1][1] = point_count
if point.getPointKind() == "Return":
info_seq[-1][2] = point.getDecision()
if point.getDecision() is True:
assert point.getPointKind() == "Return"
assert point_count < max_ws_size
if point_count > 0:
seq = dataset.evalRecSeq(condition, point_count)
ret |= set(seq)
assert len(ret) < max_ws_size
return sorted(ret), info_seq
