Return whether I have a graph by this name.
761030
def have_graph(self, graph):
        """"""
        graph = self.pack(graph)
        return bool(self.sql('graphs_named', graph).fetchone()[0])
1194012
def filtered(self, step_names):
        """"""
        return Graph(steps=self.steps, dag=self.dag.filter(step_names))
959410
def _name_exists(self, name):
        
        for i in range(self.count()):
            if self.tabText(i) == name:
                return True
        return False
259667
def get_current_name_scope():
  """"""
  # pylint: disable=protected-access
  g = tf.get_default_graph()
  # TODO(eiderman): Remove this hack once TF update is released.
  if isinstance(g._name_stack, tuple):
    return g._name_stack[0] + '/'
  else:
    return g._name_stack + '/'
605990
def has_causal_out_edges(graph: BELGraph, node: BaseEntity) -> bool:
    """"""
    return any(
        data[RELATION] in CAUSAL_RELATIONS
        for _, _, data in graph.out_edges(node, data=True)
    )
970906
private static boolean hasMembershipProps(final Graph graph) {
        return graph.contains(null, LDP.membershipResource, null)
                        && (graph.stream(null, LDP.hasMemberRelation, null).count()
                                        + graph.stream(null, LDP.isMemberOfRelation, null).count() == 1L);
    }
545408
def is_frond(u, v, dfs_data):
    """"""
    d_u = D(u, dfs_data)
    d_v = D(v, dfs_data)
    edge_id = dfs_data['graph'].get_first_edge_id_by_node_ids(u, v)
    return True if dfs_data['edge_lookup'][edge_id] == 'backedge' and d_v < d_u else False
1328895
def get_names(graph):
    
    rv = defaultdict(set)
    for namespace, name in _identifier_filtered_iterator(graph):
        rv[namespace].add(name)
    return dict(rv)
933802
def has_edge(self, node1_name, node2_name, account_for_direction=True):
        
        return self.__has_edge(node1_name=node1_name, node2_name=node2_name, account_for_direction=account_for_direction)
76747
def _naked_names_iter(graph: BELGraph) -> Iterable[str]:
    """"""
    for _, exc, _ in graph.warnings:
        if isinstance(exc, NakedNameWarning):
            yield exc.name
998919
def retrieveVals(self):
        """"""
        for graph_name in self.getGraphList():
            for field_name in self.getGraphFieldList(graph_name):
                self.setGraphVal(graph_name, field_name, self._stats.get(field_name))
3406
def graphHasField(self, graph_name, field_name):
        
        graph = self._graphDict.get(graph_name, True)
        return graph.hasField(field_name)
799252
def getSubgraphList(self, parent_name):
        
        if not self.isMultigraph:
            raise AttributeError("Simple Munin Plugins cannot have subgraphs.")
        if self._graphDict.has_key(parent_name):
            return self._subgraphNames[parent_name] or []
        else:
            raise AttributeError("Invalid parent graph name %s."
                                 % (parent_name,))
6836
def get_graph_url(self, target, graphite_url=None):
        """"""
        return self._graphite_url(target, graphite_url=graphite_url, raw_data=False)
27411
def has_predecessor(self, u, v):
        
        if u not in self.vertices:
            raise GraphInsertError("Vertex %s doesn't exist." % (u,))
        return(u in self.pred and v in self.pred[u])
697708
def contains(self, name):
    
    try:
      self._api.buckets_get(name)
    except google.datalab.utils.RequestException as e:
      if e.status == 404:
        return False
      raise e
    except Exception as e:
      raise e
    return True
550155
def graph(self):
        
        if not hasattr(self, '_graph') or self._graph is None:
            self._graph = ConjunctiveGraph(store=self.store,
                                           identifier=self.base_uri)
        return self._graph