Return all current evidences in the BN

@param bn
@return
763765
public static Map<String, String> getEvidences(ProbabilisticNetwork bn) {

        HashMap<String, String> evidences = new HashMap<String, String>();
        for (Node n : bn.getNodes()) {
            ProbabilisticNode pn = (ProbabilisticNode) n;
            if (pn.hasEvidence()) {
                evidences.put(pn.getName(), pn.getStateAt(pn.getEvidence()));
            }
        }
        return evidences;
    }
819730
def get_annotations(self) -> Dict:
        """"""
        return {
            EVIDENCE: self.evidence,
            CITATION: self.citation.copy(),
            ANNOTATIONS: self.annotations.copy()
        }
461769
def get_evidence(self, relation):
        """"""
        provenance = relation.get('provenance')

        # First try looking up the full sentence through provenance
        text = None
        context = None
        if provenance:
            sentence_tag = provenance[0].get('sentence')
            if sentence_tag and '@id' in sentence_tag:
                sentence_id = sentence_tag['@id']
                sentence = self.doc.sentences.get(sentence_id)
                if sentence is not None:
                    text = _sanitize(sentence['text'])
                # Get temporal constraints if available
                timexes = sentence.get('timexes', [])
                if timexes:
                    # We currently handle just one timex per statement
                    timex = timexes[0]
                    tc = time_context_from_timex(timex)
                    context = WorldContext(time=tc)
                # Get geolocation if available
                geolocs = sentence.get('geolocs', [])
                if geolocs:
                    geoloc = geolocs[0]
                    rc = ref_context_from_geoloc(geoloc)
                    if context:
                        context.geo_location = rc
                    else:
                        context = WorldContext(geo_location=rc)

            # Here we try to get the title of the document and set it
            # in the provenance
            doc_id = provenance[0].get('document', {}).get('@id')
            if doc_id:
                title = self.doc.documents.get(doc_id, {}).get('title')
                if title:
                    provenance[0]['document']['title'] = title

        annotations = {'found_by': relation.get('rule'),
                       'provenance': provenance}
        if self.doc.dct is not None:
            annotations['document_creation_time'] = self.doc.dct.to_json()

        epistemics = {}
        negations = self.get_negation(relation)
        hedgings = self.get_hedging(relation)
        if hedgings:
            epistemics['hedgings'] = hedgings
        if negations:
            # This is the INDRA standard to show negation
            epistemics['negated'] = True
            # But we can also save the texts associated with the negation
            # under annotations, just in case it's needed
            annotations['negated_texts'] = negations

        # If that fails, we can still get the text of the relation
        if text is None:
            text = _sanitize(event.get('text'))

        ev = Evidence(source_api='eidos', text=text, annotations=annotations,
                      context=context, epistemics=epistemics)
        return ev
282797
protected boolean getBoolean()
  {                                                     
    if (tc.isEntryEnabled()) Tr.entry(tc, "getBoolean", this);

    byte dataByte = _buffer.get();
    boolean data = (dataByte == TRUE);

    if (tc.isEntryEnabled()) Tr.exit(tc, "getBoolean", new Boolean(data));
    return data;
  }
1191537
public synchronized Set<Evidence> getEvidence(EvidenceType type) {
        if (null != type) {
            switch (type) {
                case VENDOR:
                    return Collections.unmodifiableSet(new HashSet<>(vendors));
                case PRODUCT:
                    return Collections.unmodifiableSet(new HashSet<>(products));
                case VERSION:
                    return Collections.unmodifiableSet(new HashSet<>(versions));
                default:
                    break;
            }
        }
        return null;
    }
707537
public static HashMap<String, HashMap<String, Float>> getAllHypotheses(
            Network bn) throws ShanksException {
        HashMap<String, HashMap<String, Float>> result = new HashMap<String, HashMap<String, Float>>();
        for (int node : bn.getAllNodes()) {
            String nodeName = bn.getNodeName(node);
            HashMap<String, Float> hypotheses = ShanksAgentBayesianReasoningCapability
                    .getNodeStatesHypotheses(bn, nodeName);
            result.put(nodeName, hypotheses);
        }
        return result;
    }
1272449
public List<ColumnResult<SqlResultSetMapping<T>>> getAllColumnResult()
   {
      List<ColumnResult<SqlResultSetMapping<T>>> list = new ArrayList<ColumnResult<SqlResultSetMapping<T>>>();
      List<Node> nodeList = childNode.get("column-result");
      for(Node node: nodeList)
      {
         ColumnResult<SqlResultSetMapping<T>>  type = new ColumnResultImpl<SqlResultSetMapping<T>>(this, "column-result", childNode, node);
         list.add(type);
      }
      return list;
   }
298342
public List<Scan<Beans<T>>> getAllScan()
   {
      List<Scan<Beans<T>>> list = new ArrayList<Scan<Beans<T>>>();
      List<Node> nodeList = childNode.get("scan");
      for(Node node: nodeList)
      {
         Scan<Beans<T>>  type = new ScanImpl<Beans<T>>(this, "scan", childNode, node);
         list.add(type);
      }
      return list;
   }
988460
public List<Block.Instance> getBlockInstancesForWitness(Witness w) {
        return witnessToBlockInstances.computeIfAbsent(w, v -> Collections.emptyList());
    }
87549
public Map<String, byte[]> getCurrentMembers()
    {
        ImmutableMap.Builder<String, byte[]> builder = ImmutableMap.builder();
        boolean thisIdAdded = false;
        for ( ChildData data : cache.getCurrentData() )
        {
            String id = idFromPath(data.getPath());
            thisIdAdded = thisIdAdded || id.equals(thisId);
            builder.put(id, data.getData());
        }
        if ( !thisIdAdded )
        {
            builder.put(thisId, pen.getData());   // this instance is always a member
        }
        return builder.build();
    }
357493
public static Collection<Comparable<?>> getDatabaseShardingValues(final String logicTable) {
        return null == HINT_MANAGER_HOLDER.get() ? Collections.<Comparable<?>>emptyList() : HINT_MANAGER_HOLDER.get().databaseShardingValues.get(logicTable);
    }
865628
public boolean matches(Evidence evidence) {
        return sourceMatches(evidence)
                && confidenceMatches(evidence)
                && name.equalsIgnoreCase(evidence.getName())
                && valueMatches(evidence);
    }
889195
@Override
    public Collection<org.jbpm.services.api.model.NodeInstanceDesc> getActiveNodesForCase(String caseId, QueryContext queryContext) {
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("caseId", caseId + "%");
        applyQueryContext(params, queryContext);
        applyDeploymentFilter(params);
        List<org.jbpm.services.api.model.NodeInstanceDesc> nodeInstances =  commandService.execute(new QueryNameCommand<List<org.jbpm.services.api.model.NodeInstanceDesc>>("getActiveNodesForCase", params));
        return nodeInstances;
    }
789977
def all(self):
    " "
    query,inputs = self._toedn()
    return self.db.q(query,
      inputs  = inputs,
      limit   = self._limit,
      offset  = self._offset,
      history = self._history)
1133193
protected List<T> currentResults() {
        return results == null ? Collections.emptyList()
            : Collections.unmodifiableList(results);
    }
750711
def get_current_info(self, symbolList, columns=None):
        
        response = self.select('yahoo.finance.quotes',columns).where(['symbol','in',symbolList])
        return response
1015700
def map_cbn(d):
    
    for i, edge in enumerate(d['graph']['edges']):
        if 'metadata' not in d['graph']['edges'][i]:
            continue

        if 'evidences' not in d['graph']['edges'][i]['metadata']:
            continue

        for j, evidence in enumerate(d['graph']['edges'][i]['metadata']['evidences']):
            if EXPERIMENT_CONTEXT not in evidence:
                continue

            # ctx = {k.strip().lower(): v.strip() for k, v in evidence[EXPERIMENT_CONTEXT].items() if v.strip()}

            new_context = {}

            for key, value in evidence[EXPERIMENT_CONTEXT].items():
                if not value:
                    log.debug('key %s without value', key)
                    continue

                value = value.strip()

                if not value:
                    log.debug('key %s without value', key)
                    continue

                key = key.strip().lower()

                if key == 'species_common_name':
                    new_context['Species'] = species_map[value.lower()]
                elif key in annotation_map:
                    new_context[annotation_map[key]] = value
                else:
                    new_context[key] = value

            '''
            for k, v in annotation_map.items():
                if k not in ctx:
                    continue

                d['graph']['edges'][i]['metadata']['evidences'][j][EXPERIMENT_CONTEXT][v] = ctx[k]
                del d['graph']['edges'][i]['metadata']['evidences'][j][EXPERIMENT_CONTEXT][k]

            if 'species_common_name' in ctx:
                species_name = ctx['species_common_name'].strip().lower()
                d['graph']['edges'][i]['metadata']['evidences'][j][EXPERIMENT_CONTEXT]['Species'] = species_map[
                    species_name]
                del d['graph']['edges'][i]['metadata']['evidences'][j][EXPERIMENT_CONTEXT][
                    'species_common_name']
            '''

            d['graph']['edges'][i]['metadata']['evidences'][j][EXPERIMENT_CONTEXT] = new_context

    return d