o ÒmÆip0ã@sÆdZddlmZddlZddlmZmZmZmZer ddl m Z e  e ¡Z dd„Zeefd"d d „Zdd„fd#dd„Zddd„fd"dd„Zddd„fd"dd„Zdgdgdd„dd„dd„fd$d d!„ZdS)%a”Convert (to and) from rdflib graphs to other well known graph libraries. Currently the following libraries are supported: - networkx: MultiDiGraph, DiGraph, Graph - graph_tool: Graph Doctests in this file are all skipped, as we can't run them conditionally if networkx or graph_tool are available and they would err otherwise. see `../../test/test_extras_external_graph_libs.py` for conditional tests é)Ú annotationsN)Ú TYPE_CHECKINGÚAnyÚDictÚList)ÚGraphcCs|S)N©)Úxrrú[/home/kim/smarthome/.venv/lib/python3.10/site-packages/rdflib/extras/external_graph_libs.pyÚ _identitysr ÚgraphrÚ calc_weightsÚboolcCsÚt|ƒsJ‚t|ƒs J‚t|ƒsJ‚ddl}|D]R\}}} ||ƒ|| ƒ} } | | | ¡} | dus6t||jƒrM|||| ƒ} |rBd| d<|j| | fi| ¤Žq|rW| dd7<d| vrj|||| ƒ} | d | d¡qdS)aæHelper method for multidigraph, digraph and graph. Modifies nxgraph in-place! Args: graph: an rdflib.Graph. nxgraph: a networkx.Graph/DiGraph/MultiDigraph. calc_weights: If True adds a 'weight' attribute to each edge according to the count of s,p,o triples between s and o, which is meaningful for Graph/DiGraph. edge_attrs: Callable to construct edge data from s, p, o. 'triples' attribute is handled specially to be merged. 'weight' should not be generated if calc_weights==True. (see invokers below!) transform_s: Callable to transform node generated from s. transform_o: Callable to transform node generated from o. rNéÚweightÚtriples)ÚcallableÚnetworkxZ get_edge_dataÚ isinstanceÚ MultiDiGraphÚadd_edgeÚextend)r Znxgraphr Ú edge_attrsÚ transform_sÚ transform_oÚnxÚsÚpÚoÚtsÚtoÚdataÚdrrr Ú_rdflib_to_networkx_graphs&      €ñr#cCód|iS)NÚkeyr©rrrrrr ÚNór'cKs*ddl}| ¡}t||d|fi|¤Ž|S)a&Converts the given graph into a networkx.MultiDiGraph. The subjects and objects are the later nodes of the MultiDiGraph. The predicates are used as edge keys (to identify multi-edges). Args: graph: a rdflib.Graph. edge_attrs: Callable to construct later edge_attributes. It receives 3 variables (s, p, o) and should construct a dictionary that is passed to networkx's add_edge(s, o, \*\*attrs) function. By default this will include setting the MultiDiGraph key=p here. If you don't want to be able to re-identify the edge later on, you can set this to `lambda s, p, o: {}`. In this case MultiDiGraph's default (increasing ints) will be used. Returns: networkx.MultiDiGraph Example: ```python >>> from rdflib import Graph, URIRef, Literal >>> g = Graph() >>> a, b, l = URIRef('a'), URIRef('b'), Literal('l') >>> p, q = URIRef('p'), URIRef('q') >>> edges = [(a, p, b), (a, q, b), (b, p, a), (b, p, l)] >>> for t in edges: ... g.add(t) ... >>> mdg = rdflib_to_networkx_multidigraph(g) >>> len(mdg.edges()) 4 >>> mdg.has_edge(a, b) True >>> mdg.has_edge(a, b, key=p) True >>> mdg.has_edge(a, b, key=q) True >>> mdg = rdflib_to_networkx_multidigraph(g, edge_attrs=lambda s,p,o: {}) >>> mdg.has_edge(a, b, key=0) True >>> mdg.has_edge(a, b, key=1) True ``` rNF)rrr#)r rÚkwdsrZmdgrrr Úrdflib_to_networkx_multidigraphMs1r*TcCód|||fgiS©Nrrr&rrr r'ˆócKó*ddl}| ¡}t||||fi|¤Ž|S)aCConverts the given graph into a networkx.DiGraph. As an rdflib.Graph() can contain multiple edges between nodes, by default adds the a 'triples' attribute to the single DiGraph edge with a list of all triples between s and o. Also by default calculates the edge weight as the length of triples. Args: graph: a rdflib.Graph. calc_weights: If true calculate multi-graph edge-count as edge 'weight' edge_attrs: Callable to construct later edge_attributes. It receives 3 variables (s, p, o) and should construct a dictionary that is passed to networkx's add_edge(s, o, \*\*attrs) function. By default this will include setting the 'triples' attribute here, which is treated specially by us to be merged. Other attributes of multi-edges will only contain the attributes of the first edge. If you don't want the 'triples' attribute for tracking, set this to `lambda s, p, o: {}`. Returns: networkx.DiGraph Example: ```python >>> from rdflib import Graph, URIRef, Literal >>> g = Graph() >>> a, b, l = URIRef('a'), URIRef('b'), Literal('l') >>> p, q = URIRef('p'), URIRef('q') >>> edges = [(a, p, b), (a, q, b), (b, p, a), (b, p, l)] >>> for t in edges: ... g.add(t) ... >>> dg = rdflib_to_networkx_digraph(g) >>> dg[a][b]['weight'] 2 >>> sorted(dg[a][b]['triples']) == [(a, p, b), (a, q, b)] True >>> len(dg.edges()) 3 >>> dg.size() 3 >>> dg.size(weight='weight') 4.0 >>> dg = rdflib_to_networkx_graph(g, False, edge_attrs=lambda s,p,o:{}) >>> 'weight' in dg[a][b] False >>> 'triples' in dg[a][b] False ``` rN)rZDiGraphr#)r r rr)rÚdgrrr Úrdflib_to_networkx_digraph…ó9r0cCr+r,rr&rrr r'Èr-cKr.)aiConverts the given graph into a networkx.Graph. As an [`rdflib.Graph()`][rdflib.Graph] can contain multiple directed edges between nodes, by default adds the a 'triples' attribute to the single DiGraph edge with a list of triples between s and o in graph. Also by default calculates the edge weight as the `len(triples)`. Args: graph: a rdflib.Graph. calc_weights: If true calculate multi-graph edge-count as edge 'weight' edge_attrs: Callable to construct later edge_attributes. It receives 3 variables (s, p, o) and should construct a dictionary that is passed to networkx's add_edge(s, o, \*\*attrs) function. By default this will include setting the 'triples' attribute here, which is treated specially by us to be merged. Other attributes of multi-edges will only contain the attributes of the first edge. If you don't want the 'triples' attribute for tracking, set this to `lambda s, p, o: {}`. Returns: networkx.Graph Example: ```python >>> from rdflib import Graph, URIRef, Literal >>> g = Graph() >>> a, b, l = URIRef('a'), URIRef('b'), Literal('l') >>> p, q = URIRef('p'), URIRef('q') >>> edges = [(a, p, b), (a, q, b), (b, p, a), (b, p, l)] >>> for t in edges: ... g.add(t) ... >>> ug = rdflib_to_networkx_graph(g) >>> ug[a][b]['weight'] 3 >>> sorted(ug[a][b]['triples']) == [(a, p, b), (a, q, b), (b, p, a)] True >>> len(ug.edges()) 2 >>> ug.size() 2 >>> ug.size(weight='weight') 4.0 >>> ug = rdflib_to_networkx_graph(g, False, edge_attrs=lambda s,p,o:{}) >>> 'weight' in ug[a][b] False >>> 'triples' in ug[a][b] False ``` rN)rrr#)r r rr)rÚgrrr Úrdflib_to_networkx_graphÅr1r3ÚtermcCsd|iS©Nr4rr&rrr r' r(cCr$r5rr&rrr r' r(cCsd|iSr5rr&rrr r' r(Ú v_prop_namesú List[str]Ú e_prop_namescsFddl}| ¡‰‡fdd„|Dƒ}|D] \}} | ˆj|<q‡fdd„|Dƒ} | D] \} } | ˆj| <q(i} |D]j\}}}|  |¡}|duraˆ ¡}|| |<||||ƒ}|D] \}} ||| |<qT|}|  |¡}|dur‡ˆ ¡}|| |<||||ƒ}|D] \}} ||| |<qz|}ˆ ||¡}||||ƒ}| D] \} } || | |<q•q6ˆS)aa Converts the given graph into a graph_tool.Graph(). The subjects and objects are the later vertices of the Graph. The predicates become edges. Args: graph: a rdflib.Graph. v_prop_names: a list of names for the vertex properties. The default is set to ['term'] (see transform_s, transform_o below). e_prop_names: a list of names for the edge properties. transform_s: callable with s, p, o input. Should return a dictionary containing a value for each name in v_prop_names. By default is set to {'term': s} which in combination with v_prop_names = ['term'] adds s as 'term' property to the generated vertex for s. transform_p: similar to transform_s, but wrt. e_prop_names. By default returns {'term': p} which adds p as a property to the generated edge between the vertex for s and the vertex for o. transform_o: similar to transform_s. Returns: graph_tool.Graph() Example: ```python >>> from rdflib import Graph, URIRef, Literal >>> g = Graph() >>> a, b, l = URIRef('a'), URIRef('b'), Literal('l') >>> p, q = URIRef('p'), URIRef('q') >>> edges = [(a, p, b), (a, q, b), (b, p, a), (b, p, l)] >>> for t in edges: ... g.add(t) ... >>> mdg = rdflib_to_graphtool(g) >>> len(list(mdg.edges())) 4 >>> from graph_tool import util as gt_util >>> vpterm = mdg.vertex_properties['term'] >>> va = gt_util.find_vertex(mdg, vpterm, a)[0] >>> vb = gt_util.find_vertex(mdg, vpterm, b)[0] >>> vl = gt_util.find_vertex(mdg, vpterm, l)[0] >>> (va, vb) in [(e.source(), e.target()) for e in list(mdg.edges())] True >>> epterm = mdg.edge_properties['term'] >>> len(list(gt_util.find_edge(mdg, epterm, p))) == 3 True >>> len(list(gt_util.find_edge(mdg, epterm, q))) == 1 True >>> mdg = rdflib_to_graphtool( ... g, ... e_prop_names=[str('name')], ... transform_p=lambda s, p, o: {str('name'): unicode(p)}) >>> epterm = mdg.edge_properties['name'] >>> len(list(gt_util.find_edge(mdg, epterm, unicode(p)))) == 3 True >>> len(list(gt_util.find_edge(mdg, epterm, unicode(q)))) == 1 True ``` rNcóg|] }|ˆ d¡f‘qS©Úobject)Znew_vertex_property)Ú.0Úvpn©r2rr Ú Lóz'rdflib_to_graphtool..cr9r:)Znew_edge_property)r<Úepnr>rr r?Or@)Z graph_toolrZvertex_propertiesZedge_propertiesÚgetZ add_vertexr)r r6r8rZ transform_prÚgtZvpropsr=ZvpropZepropsrAZepropZnode_to_vertexrrrÚsvÚvZ tmp_propsÚovÚerr>r Úrdflib_to_graphtools@C             ÿrH)r rr r)r r)r rr6r7r8r7)Ú__doc__Ú __future__rÚloggingÚtypingrrrrZ rdflib.graphrÚ getLoggerÚ__name__Úloggerr r#r*r0r3rHrrrr Ús2     ú1 ÿ: ýB ýBú