Return the cause repertoire.
481434
def cause_repertoire(self, mechanism, purview):
        """"""
        return self.repertoire(Direction.CAUSE, mechanism, purview)
103444
def _analyze_root_causes(self):
        
        causes = {}
        for a in self.anomalies:
            try:
                causes[a] = self.correlations[a][0]
            except IndexError:
                raise exceptions.InvalidDataFormat('luminol.luminol: dict correlations contains empty list.')
        self.causes = causes
1369791
def cause_mip(self, mechanism, purview):
        
        return self.find_mip(Direction.CAUSE, mechanism, purview)
12655
def extract_statements(self):
        """"""
        for _, (tf, target, effect, refs) in self.df.iterrows():
            tf_agent = get_grounded_agent(tf)
            target_agent = get_grounded_agent(target)
            if effect == 'Activation':
                stmt_cls = IncreaseAmount
            elif effect == 'Repression':
                stmt_cls = DecreaseAmount
            else:
                continue
            pmids = refs.split(';')
            for pmid in pmids:
                stmt = make_stmt(stmt_cls, tf_agent, target_agent, pmid)
                self.statements.append(stmt)
1025109
def mechanism(self):
        """"""
        assert self.actual_cause.mechanism == self.actual_effect.mechanism
        return self.actual_cause.mechanism
383436
def GetConfigPolicy(self, request, context):
        """"""
        try:
            policy = self.plugin.get_config_policy()
            return policy._pb
        except Exception as err:
            msg = "message: {}\n\nstack trace: {}".format(
                err.message, traceback.format_exc())
            return GetConfigPolicyReply(error=msg)
1060215
def error_lineno(self):
        """"""
        if isinstance(self.docstring, Docstring):
            return self.docstring.start
        return self.start
115617
def add_cause(self, error: Exception):
        ''''''
        self.add_info('Cause error', '{0} - {1}'.format(type(error).__name__, error))
1124495
def get_cases(self, target):
        """"""
        if target in self.targets:
            return self._reverse_map[target]

        raise KeyError("Target 0x{:08X} does not exist.".format(target))
635423
def expand_cause_repertoire(self, new_purview=None):
        """"""
        return self.subsystem.expand_cause_repertoire(
            self.cause.repertoire, new_purview)
165669
def expand_effect_repertoire(self, repertoire, new_purview=None):
        
        return self.expand_repertoire(Direction.EFFECT, repertoire,
                                      new_purview)
747613
def ILIKE(pattern):
    """"""
    return P(lambda x: fnmatch.fnmatch(x.lower(), pattern.lower()))
199246
def get(self):
        """"""
        namespaces = db.ConfigNamespace.order_by(
            ConfigNamespace.sort_order,
            ConfigNamespace.name
        ).all()

        return self.make_response({
            'message': None,
            'namespaces': namespaces
        }, HTTP.OK)
366210
function() {
        var orderedCauses = [],
            totalConstantOccurences = [];

        for (var i = 0; i < this.causes.length; i++) {
            var cause = this.causes[i],
                constantOccurences = 0;
            if (!(cause.subject.indexOf('?') === 0)) {
                constantOccurences++;
            }
            if (!(cause.predicate.indexOf('?') === 0)) {
                constantOccurences++;
            }
            if (!(cause.object.indexOf('?') === 0)) {
                constantOccurences++;
            }
            totalConstantOccurences.push({
                cause: cause,
                constantOccurences: constantOccurences
            });
        }

        totalConstantOccurences = totalConstantOccurences.sort(function(a, b) {
            var x = a.constantOccurences; var y = b.constantOccurences;
            return ((x > y) ? -1 : ((x < y) ? 1 : 0));
        });

        for(var i = 0; i < totalConstantOccurences.length; i++) {
            orderedCauses.push(totalConstantOccurences[i].cause);
        }

        this.causes = orderedCauses;
    }
84202
def incidental (self):
        
        result = [p for p in self.lazy_properties if p.feature.incidental]
        result.extend(self.incidental_)
        return result
213804
def GetPattern(self):
    """"""
    stoptimes = self.GetStopTimes()
    return tuple(st.stop for st in stoptimes)
1081281
def expand_effect_repertoire(self, new_purview=None):
        """"""
        return self.subsystem.expand_effect_repertoire(
            self.effect.repertoire, new_purview)