Returns true if there is evidence that the statement is only
    hypothetical. If all of the evidences associated with the statement
    indicate a hypothetical interaction then we assume the interaction
    is hypothetical.
433519
def _get_is_hypothesis(stmt):
    ''''''
    for ev in stmt.evidence:
        if not ev.epistemics.get('hypothesis') is True:
            return True
    return False
213250
private boolean isReconciling() {
        AggregatorState currentState = this.state.get();
        return currentState == AggregatorState.ReconciliationNeeded
                || currentState == AggregatorState.Reconciling;
    }
168906
public boolean hasState() {
		for (OperatorSubtaskState operatorSubtaskState : subtaskStatesByOperatorID.values()) {
			if (operatorSubtaskState != null && operatorSubtaskState.hasState()) {
				return true;
			}
		}
		return false;
	}
1229651
@Override
    public boolean isPrecomputed(InferenceType inferenceType) {
        if (inferenceType.equals(InferenceType.CLASS_HIERARCHY)) {
            return reasoner.isClassified();
        } else {
            return false;
        }
    }
487554
def hasBidAsk(self) -> bool:
        
        return (
            self.bid != -1 and not isNan(self.bid) and self.bidSize > 0 and
            self.ask != -1 and not isNan(self.ask) and self.askSize > 0)
946200
public boolean hasUsersInOtherOus() {

        if (m_lazy) {
            // if we use database-side paging, we have to assume that there may be users from other OUs
            return true;
        }
        if (m_hasUsersInOtherOus == null) {
            // lazzy initialization
            m_hasUsersInOtherOus = Boolean.FALSE;
            try {
                Iterator<CmsUser> itUsers = getUsers(true).iterator();
                while (itUsers.hasNext()) {
                    CmsUser user = itUsers.next();
                    if (!user.getOuFqn().equals(getParamOufqn())) {
                        m_hasUsersInOtherOus = Boolean.TRUE;
                        break;
                    }
                }
            } catch (Exception e) {
                // ignore
            }
        }
        return m_hasUsersInOtherOus.booleanValue();
    }
161634
def argument(self) -> bool:
        
        next = self.peek()
        if next == "'":
            quoted = True
            self.sq_argument()
        elif next == '"':
            quoted = True
            self.dq_argument()
        elif self._arg == "":
            quoted = False
            self.unq_argument()
        else:
            raise UnexpectedInput(self, "single or double quote")
        self.opt_separator()
        next = self.peek()
        if next == ";":
            return False
        if next == "{":
            return True
        elif quoted and next == "+":
            self.offset += 1
            self.opt_separator()
            return self.argument()
        else:
            raise UnexpectedInput(self, "';', '{'" +
                                  (" or '+'" if quoted else ""))
277673
def has_hints(self):
        
        for acc in ["low", "normal", "high"]:
            try:
                if self.hint_for_accuracy(acc) is None:
                    return False
            except KeyError:
                return False
        return True
806012
public boolean hasPrincipalsInOtherOus() {

        if (m_hasPrincipalsInOtherOus == null) {
            // lazzy initialization
            m_hasPrincipalsInOtherOus = Boolean.FALSE;
            try {
                Iterator<CmsPrincipal> itPrincipals = getPrincipals(true).iterator();
                while (itPrincipals.hasNext()) {
                    CmsPrincipal principal = itPrincipals.next();
                    if (!principal.getOuFqn().equals(getCms().getRequestContext().getCurrentUser().getOuFqn())) {
                        m_hasPrincipalsInOtherOus = Boolean.TRUE;
                        break;
                    }
                }
            } catch (Exception e) {
                // ignore
            }
        }
        return m_hasPrincipalsInOtherOus.booleanValue();
    }
1375031
public boolean isFullyEstablished() {
        boolean result = true;

        MediaNegotiator mediaNeg = getMediaNegotiator();
        if ((mediaNeg == null) || !mediaNeg.isFullyEstablished()) {
            result = false;
        }

        TransportNegotiator transNeg = getTransportNegotiator();
        if ((transNeg == null) || !transNeg.isFullyEstablished()) {
            result = false;
        }

        return result;
    }
109872
private boolean hasConditionalBranches( Tree<Row> split ){
        for( Tree<Row> branch : split.getChildren() ){
            Element main = branch.getContent().getMainElement();
            if( main.countArguments() > 0 ){
                return true;
            }
        }
        return false;
    }
677297
private boolean closeStatements() {

      // JDBC API says...
      // Calling the method close on a Statement object that is already closed has no effect.
      // Note: When a Statement object is closed, its current ResultSet object, if one exists, is also closed.

      boolean hasUnclosed = false;

      if(openStatements.size() > 0) {
         for(Statement stmt : openStatements) {
            try {
               if(!stmt.isClosed()) {
                  stmt.close();
                  hasUnclosed = true;
               }
            } catch(SQLException e) {
               hasUnclosed = true;
               setLogicalCloseException(e);
            } catch(Throwable t) {
               hasUnclosed = true;
               if(logicalCloseException == null) {
                  if(Util.isRuntimeError(t)) {
                     setLogicalCloseException(t);
                  } else {
                     setLogicalCloseException(new SQLException(t));
                  }
               }
            }
         }

         openStatements.clear();
      }

      return hasUnclosed;
   }
430172
public boolean hasState(ConversationState... states) {
		for (ConversationState s : states) {
			if (s.equals(state)) {
				return true;
			}
		}
		return false;
	}
1158511
def is_well_grounded_statement(s: Influence, cutoff: float = 0.7) -> bool:
    

    return all(
        map(lambda c: is_well_grounded_concept(c, cutoff), s.agent_list())
    )
1078569
def is_conditional(self, include_loop=True):
        
        if self.contains_if(include_loop) or self.contains_require_or_assert():
            return True
        if self.irs:
            last_ir = self.irs[-1]
            if last_ir:
                if isinstance(last_ir, Return):
                    for r in last_ir.read:
                        if r.type == ElementaryType('bool'):
                            return True
        return False
887590
public boolean hasData() {
        int apos = token.length - 1;
        int rpos = pos - 1;
        for (; rpos > -1 && apos > -1; rpos--, apos--) {
            if (buffer2[rpos] != -1) {
                return true;
            }
        }
        for (rpos = buffer2.length - 1; apos > -1; rpos--, apos--) {
            if (buffer2[rpos] != -1) {
                return true;
            }
        }
        return false;
    }
440303
def is_background_knowledge(stmt):
    ''''''
    any_background = False
    # Iterate over all evidence for the statement
    for ev in stmt.evidence:
        epi = ev.epistemics
        if epi is not None:
            sec = epi.get('section_type')
            # If there is at least one evidence not from a 
            # background section then we consider this to be
            # a non-background knowledge finding.
            if sec is not None and sec not in background_secs:
                return False
            # If there is at least one evidence that is explicitly
            # from a background section then we keep track of that.
            elif sec in background_secs:
                any_background = True
    # If there is any explicit evidence for this statement being
    # background info (and no evidence otherwise) then we return
    # True, otherwise (for instnace of there is no section info at all)
    # we return False.
    return any_background