Return the cause-effect information for a mechanism over a purview.

        This is the minimum of the cause and effect information.
174594
def cause_effect_info(self, mechanism, purview):
        
        return min(self.cause_info(mechanism, purview),
                   self.effect_info(mechanism, purview))
287052
def _get_retry_delay(cause):
    
    metadata = dict(cause.trailing_metadata())
    retry_info_pb = metadata.get("google.rpc.retryinfo-bin")
    if retry_info_pb is not None:
        retry_info = RetryInfo()
        retry_info.ParseFromString(retry_info_pb)
        nanos = retry_info.retry_delay.nanos
        return retry_info.retry_delay.seconds + nanos / 1.0e9
525782
def probability(self, direction, mechanism, purview):
        
        repertoire = self.repertoire(direction, mechanism, purview)

        return self.state_probability(direction, repertoire, purview)
735996
def null_concept(self):
        
        # Unconstrained cause repertoire.
        cause_repertoire = self.cause_repertoire((), ())
        # Unconstrained effect repertoire.
        effect_repertoire = self.effect_repertoire((), ())

        # Null cause.
        cause = MaximallyIrreducibleCause(
            _null_ria(Direction.CAUSE, (), (), cause_repertoire))
        # Null effect.
        effect = MaximallyIrreducibleEffect(
            _null_ria(Direction.EFFECT, (), (), effect_repertoire))

        # All together now...
        return Concept(mechanism=(),
                       cause=cause,
                       effect=effect,
                       subsystem=self)
1051686
def _get_min_addr(self):
        

        if not self._regions:
            if self.project.arch.name != "Soot":
                l.error("self._regions is empty or not properly set.")
            return None

        return next(self._regions.irange())
802647
def func(self):
        """"""
        fn = self.engine.query.sense_func_get(
            self.observer.name,
            self.sensename,
            *self.engine._btt()
        )
        if fn is not None:
            return SenseFuncWrap(self.observer, fn)
271465
def standard_exc_info(self):
        """"""
        tb = self.frames[0]
        # the frame will be an actual traceback (or transparent proxy) if
        # we are on pypy or a python implementation with support for tproxy
        if type(tb) is not TracebackType:
            tb = tb.tb
        return self.exc_type, self.exc_value, tb
832403
def info(self, action=None):
        
        if action in self.cache:
            return self.cache[action]['info']
        return self.cache.keys() or None
481434
def cause_repertoire(self, mechanism, purview):
        """"""
        return self.repertoire(Direction.CAUSE, mechanism, purview)
332114
def find_actual_cause(self, mechanism, purviews=False):
        """"""
        return self.find_causal_link(Direction.CAUSE, mechanism, purviews)
712685
def get_info(self, params={}):
        
        res = self.invoke(zconstant.NS_ZIMBRA_ACC_URL,
                          sconstant.GetInfoRequest,
                          params)

        return res
150456
def _get_mechanism(self, sites, rup, imt, C):
        
        Fn, Fr = self._get_fault_type_dummy_variables(sites, rup, imt)
        return (C['b9'] * Fn) + (C['b10'] * Fr)
1186938
def _checkIdEquality(self, requestedEffect, effect):
        
        return self._idPresent(requestedEffect) and (
            effect.term_id == requestedEffect.term_id)
797830
def _info(self):
        
        name = self.__class__.__module__ + '.' + self.__class__.__name__
        info, created = ModuleInfo.objects.get_or_create(name=name)
        if created:
            # Do not set as changed
            info.commit()
        return info
91696
def view(self):
        
        proxied = get_proxied_expr(self)
        kv = dict((attr, getattr(proxied, attr)) for attr in get_attrs(proxied))
        return type(proxied)(**kv)
966370
def mechanism_indices(self, direction):
        """"""
        return {
            Direction.CAUSE: self.effect_indices,
            Direction.EFFECT: self.cause_indices
        }[direction]
718280
def potential_purviews(self, direction, mechanism, purviews=False):
        """"""
        all_purviews = utils.powerset(self.node_indices)
        return irreducible_purviews(
            self.cm, direction, mechanism, all_purviews)