U td~@s ddlmZmZddlmZddlmZddlmZddl m Z d(e e e d d d Z d)e e d ddZd*e e d ddZd+e e d ddZd,e e dddZd-e e e dddZd.e ee ee fe dddZdedfe ee ddd Zd/e ee ee fe e d!d"d#Zd$d%Zd&d'Zd S)0)UnionSequence) defaultdict)repeat)warn)UniqueIdGeneratorFnamesourcetarget)directedvertex_name_attr iterativec Csdd}i}d} |rt|D]\\} } | D]B\} } z|| | | fWq,tk rl| | fg|| <Yq,Xq,| d7} q|D]\} } || | || <qng||<||krt|d||}t|tt|krtdt|d}|\}}|r|| g|i|}t|D]\} }||}||}||}|| krX| d||j | |<| d7} ||}|| kr| d||j | |<| d7} | |||D]\} } | |j | | <qq|Sg}i}d}t|D]\} }|||}|||}|||f|D]F\} } z|| | | fWn$tk rL| | fg|| <YnXq |d7}q|D]\} } || ||| <qft|| krt|| }dg|}|D]\} } | |qt|||<t|} || ||i||SdS) a Constructs a graph from a list-of-dictionaries representation. This function is useful when you have two lists of dictionaries, one for vertices and one for edges, each containing their attributes (e.g. name, weight). Of course, the edge dictionary must also contain two special keys that indicate the source and target vertices connected by that edge. Non-list iterables should work as long as they yield dictionaries or dict-like objects (they should have the 'items' and '__getitem__' methods). For instance, a database query result is likely to be fit as long as it's iterable and yields dict-like objects with every iteration. @param vertices: the list of dictionaries for the vertices or C{None} if there are no special attributes assigned to vertices and we should simply use the edge list of dicts to infer vertex names. @param edges: the list of dictionaries for the edges. Each dict must have at least the two keys specified by edge_foreign_keys to label the source and target vertices, while additional items will be treated as edge attributes. @param directed: whether the constructed graph will be directed @param vertex_name_attr: the name of the distinguished key in the dicts in the vertex data source that contains the vertex names. Ignored if C{vertices} is C{None}. @param edge_foreign_keys: tuple specifying the attributes in each edge dictionary that contain the source (1st) and target (2nd) vertex names. These items of each dictionary are also added as edge_attributes. @param iterative: whether to add the edges to the graph one by one, iteratively, or to build a large edge list first and use that to construct the graph. The latter approach is faster but it may not be suitable if your dataset is large. The default is to add the edges in a batch from an edge list. @return: the graph that was constructed Example: >>> vertices = [{'name': 'apple'}, {'name': 'pear'}, {'name': 'peach'}] >>> edges = [{'source': 'apple', 'target': 'pear', 'weight': 1.2}, ... {'source': 'apple', 'target': 'peach', 'weight': 0.9}] >>> g = Graph.DictList(vertices, edges) The graph has three vertices with names and two edges with weights. cSs$dg|}|D]\}}|||<q|SN)indicesnresultivrrJ/home/sam/Atlas/atlas_env/lib/python3.8/site-packages/igraph/io/objects.pycreate_list_from_indices<s   zA_construct_graph_from_dict_list..create_list_from_indicesrz) is not a key of your vertex dictionarieszvertex names are not unique)initialN) enumerateitemsappendKeyErrorAttributeErrorlenset ValueErrorrZ add_verticesvsZadd_edgeesextendlistvalues)clsverticesedgesr r Zedge_foreign_keysrrZ vertex_attrsridxZ vertex_datakrZ vertex_namesZvertex_name_mapZefk_srcZefk_destgZ edge_datasrc_namedst_nameZv1Zv2 edge_list edge_attrsmdiffmorerrr_construct_graph_from_dict_list s3            r4N)r r c Cs|dkr(|sd}q4t|ts d}|g}n |r4tdt|trD|g}t}g}i}|D] } g|| <qV|D]p} ||| d|| dft|dD]B\} } z|| | | Wqtk r|| dYqXqqhi} t|| |<t |} || ||i| |S)a Constructs a graph from a list-of-tuples representation. This representation assumes that the edges of the graph are encoded in a list of tuples (or lists). Each item in the list must have at least two elements, which specify the source and the target vertices of the edge. The remaining elements (if any) specify the edge attributes of that edge, where the names of the edge attributes originate from the C{edge_attrs} list. The names of the vertices will be stored in the vertex attribute given by C{vertex_name_attr}. The default parameters of this function are suitable for creating unweighted graphs from lists where each item contains the source vertex and the target vertex. If you have a weighted graph, you can use items where the third item contains the weight of the edge by setting C{edge_attrs} to C{"weight"} or C{["weight"]}. If you have even more edge attributes, add them to the end of each item in the C{edges} list and also specify the corresponding edge attribute names in C{edge_attrs} as a list. @param edges: the data source for the edges. This must be a list where each item is a tuple (or list) containing at least two items: the name of the source and the target vertex. Note that names will be assigned to the C{name} vertex attribute (or another vertex attribute if C{vertex_name_attr} is specified), even if all the vertex names in the list are in fact numbers. @param directed: whether the constructed graph will be directed @param vertex_name_attr: the name of the vertex attribute that will contain the vertex names. @param edge_attrs: the names of the edge attributes that are filled with the extra items in the edge list (starting from index 2, since the first two items are the source and target vertices). If C{None} or an empty sequence, only the source and target vertices will be extracted and additional tuple items will be ignored. If a string, it is interpreted as a single edge attribute. @param weights: alternative way to specify that the graph is weighted. If you set C{weights} to C{true} and C{edge_attrs} is not given, it will be assumed that C{edge_attrs} is C{["weight"]} and igraph will parse the third element from each item into an edge weight. If you set C{weights} to a string, it will be assumed that C{edge_attrs} contains that string only, and igraph will store the edge weights in that attribute. @return: the graph that was constructed Nrweightz3`weights` must be False if `edge_attrs` is not Nonerr) isinstancestrr!rrr IndexErrorr%r&r)r'r)r r r0weightsZidgenr/edge_attributesritemindexvertex_attributesrrrr _construct_graph_from_tuple_lists43   r?c stt|d}t|ttfs$tdi}t|trtg}|D]*\}}||fdd|DqD ||<t } nFg}d} |D],\}}t | |f|} |t t ||q| d7} || ||i|iS)a9Constructs a graph from a dict-of-lists representation. This function is used to construct a graph from a dictionary of lists. Other, non-list sequences (e.g. tuples) and lazy iterators are are accepted. For each key x, its corresponding value must be a sequence of multiple values y: the edge (x,y) will be created in the graph. x and y must be either one of: - two integers: the vertices with those ids will be connected - two strings: the vertices with those names will be connected If names are used, the order of vertices is not guaranteed, and each vertex will be given the vertex_name_attr attribute. @param edges: the dict of sequences describing the edges @param directed: whether to create a directed graph @param vertex_name_attr: vertex attribute that will store the names @returns: a Graph object Example: >>> mydict = {'apple': ['pear', 'peach'], 'pear': ['peach']} >>> g = Graph.ListDict(mydict) # The graph has three vertices with names and three edges connecting # each pair. r Keys must be integers or stringsc3s|]}|fVqdSrr).0r name_map source_idrr sz2_construct_graph_from_list_dict..r)nextiterr7intr8r!rrr$r&rmaxzipr) r'r)r r first_itemr>r/r sequencerrrBr_construct_graph_from_list_dicts&"   rNcCsDtt|d}t|ttfs$tdi}g}t|trt}g}|D]>\} } || } | D]$\} } || || f|| q`qH| ||<t |}n\g}d}|D]B\} } t || f| }| D] \} } || | f|| qq|d7}||||i|i}t |j |D]&\}} | D]\}}|||<q(q|S)a9Constructs a graph from a dict-of-dicts representation. Each key can be an integer or a string and represent a vertex. Each value is a dict representing edges (outgoing if the graph is directed) from that vertex. Each dict key is an integer/string for a target vertex, such that an edge will be created between those two vertices. Integers are interpreted as vertex_ids from 0 (as used in igraph), strings are interpreted as vertex names, in which case vertices are given separate numeric ids. Each value is a dictionary of edge attributes for that edge. Example: >>> {'Alice': {'Bob': {'weight': 1.5}, 'David': {'weight': 2}}} creates a graph with three vertices (Alice, Bob, and David) and two edges: - Alice - Bob (with weight 1.5) - Alice - David (with weight 2) @param edges: the dict of dict of dicts specifying the edges and their attributes @param directed: whether to create a directed graph @param vertex_name_attr: vertex attribute that will store the names @returns: a Graph object rr@rFr)rGrHr7rIr8r!rrrr&rrJrKr#)r'r)r r rLr>Zedge_attribute_listrCr/r target_dictrDr r0rgraphedgekeyvalrrr_construct_graph_from_dict_dict,s8    rTT)r use_vidsc Csrz ddl}Wntk r(tdYnXz ddl}Wntk rRtdYnX|jddkrjtd|dk r|jddkrtd|rt|jdd rt|jdd r|jddddf j dd rtd |jddddfdkj dd r.td nt d |j dd|dk rl| }|j|jt|jdslt|jjdst d|jjn6|jdkj dd rtdntd|jddn|jddddf j dd rtd|}|jddddfjddd|dkrJ|d||jddddfi}|jdddf rtd|}|jdddfjddd|jdddf rtd|jddkrd|jddkrtd|j|jddidd jdd}|j|j|jdddfd}|}|jdddf |||jd<|jdddf |||jd<|dkr|jddddf!!d}|||d} nf|jddddf"|jj#dd std|jd}|||d} |jD]} ||  | j$| <qt%|jddddfj&ddd} |jddkr^|jddddfj'd d!nd} | (| | | S)"aGenerates a graph from one or two dataframes. @param edges: pandas DataFrame containing edges and metadata. The first two columns of this DataFrame contain the source and target vertices for each edge. These indicate the vertex IDs as nonnegative integers rather than vertex names unless C{use_vids} is False. Further columns may contain edge attributes. @param directed: whether the graph is directed @param vertices: None (default) or pandas DataFrame containing vertex metadata. The DataFrame's index must contain the vertex IDs as a sequence of intergers from 0 to C{len(vertices) - 1}. If C{use_vids} is C{False}, the first column must contain the unique vertex names. Vertex names should be strings for full compatibility, but many functions will work if you set the name with any hashable object. All other columns will be added as vertex attributes by column name. @param use_vids: whether to interpret the first two columns of the C{edges} argument as vertex ids (0-based integers) instead of vertex names. If this argument is set to True and the first two columns of C{edges} are not integers, an error is thrown. @return: the graph Vertex names in either the C{edges} or C{vertices} arguments that are set to NaN (not a number) will be set to the string "NA". That might lead to unexpected behaviour: fill your NaNs with values before calling this function to mitigate. rN7You should install pandas in order to use this functionz6You should install numpy in order to use this functionrr6z7The 'edges' DataFrame must contain at least two columnsz9The 'vertices' DataFrame must contain at least one column)rIZInt)Zaxisz&Source and target IDs must not be nullz*Source and target IDs must not be negativez>> g = Graph([(0, 1), (1, 2)]) >>> g.vs["name"] = ["apple", "pear", "peach"] >>> g.es["name"] = ["first_edge", "second"] >>> g.to_dict_list() ([{"name": "apple"}, {"name": "pear"}, {"name": "peach"}], [{"source": 0, "target": 1, "name": "first_edge"}, {"source" 0, "target": 2, name": "second"}]) >>> g.to_dict_list(use_vids=False) ([{"name": "apple"}, {"name": "pear"}, {"name": "peach"}], [{"source": "apple", "target": "pear", "name": "first_edge"}, {"source" "apple", "target": "peach", name": "second"}]) @param use_vids: whether to label vertices in the output data structure by their ids or their vertex_name_attr attribute. If use_vids=False but vertices lack a vertex_name_attr attribute, an AttributeError is raised. @param skip_none: whether to skip, for each edge, attributes that have a value of None. This is useful if only some edges are expected to possess an attribute. @param vertex_name_attr: only used with use_vids=False to choose what vertex attribute to use to name your vertices in the output data structure. @return: a tuple with two lists of dictionaries, representing the vertices and the edges, respectively, with their attributes. No vertex attribute cSsi|]\}}|dk r||qSrrrAr+rrrr 3sz._export_graph_to_dict_list..cSsi|]\}}|dk r||qSrrrrrrrrs=sr r )r>rr" attributesrr#tuple) rPrUrpr Zres_vsZres_esvs_namesZvertexattrdicrQr r rrr_export_graph_to_dict_lists*)        rx)rUr0r c sg}|dk rHt|tr|g}tt|t|}|rLtd|ng}|dkrx||krntd||j|}|jD]Pj \}}|s||||}}||g} | fdd|D7} | t | q~|S)aAExport graph to a list of edge tuples This function is the reverse of Graph.TupleList. Example: >>> g = Graph.Full(3) >>> g.vs["name"] = ["apple", "pear", "peach"] >>> g.es["name"] = ["first_edge", "second", "third"] >>> # Get name of the edge >>> g.to_tuple_list(edge_attrs=["name"]) [(0, 1, "first_edge"), (0, 2, "second"), (1, 2, "third")] >>> # Use vertex names, no edge attributes >>> g.to_tuple_list(use_vids=False) [("apple", "pear"), ("apple", "peach"), ("pear", "peach")] @param use_vids: whether to label vertices in the output data structure by their ids or their vertex_name_attr attribute. If use_vids=False but vertices lack a vertex_name_attr attribute, an AttributeError is raised. @param edge_attrs: list of edge attributes to export in addition to source and target vertex, which are always the first two elements of each tuple. None (default) is equivalent to an empty list. A string is acceptable to signify a single attribute and will be wrapped in a list internally. @param vertex_name_attr: only used with use_vids=False to choose what vertex attribute to use to name your vertices in the output data structure. @return: a list of tuples, each representing an edge of the graph. NMissing attributes: Frqcsg|] }|qSrr)rAattrnamerQrr sz/_export_graph_to_tuple_list..) r7r8r%r r;rr>r"r#rur) rPrUr0r res missing_attrsrvr r Zattrlistrr{r_export_graph_to_tuple_listHs((     r)rUsequence_constructorr c s|s*||kr td|d|j|}tt}|jD]0}|j\}}|sZ||}||}|||q8fdd|D}|S)aExport graph to a dictionary of lists (or other sequences). This function is the reverse of Graph.ListDict. Example: >>> g = Graph.Full(3) >>> g.to_sequence_dict() -> {0: [1, 2], 1: [2]} >>> g.to_sequence_dict(sequence_constructor=tuple) -> {0: (1, 2), 1: (2,)} >>> g.vs['name'] = ['apple', 'pear', 'peach'] >>> g.to_sequence_dict(use_vids=False) {'apple': ['pear', 'peach'], 'pear': ['peach']} @param use_vids: whether to label vertices in the output data structure by their ids or their vertex_name_attr attribute. If use_vids=False but vertices lack a vertex_name_attr attribute, an AttributeError is raised. @param sequence_constructor: constructor for the data structure to be used as values of the dictionary. The default (list) makes a dict of lists, with each list representing the neighbors of the vertex specified in the respective dictionary key. @param vertex_name_attr: only used with use_vids=False to choose what vertex attribute to use to name your vertices in the output data structure. @return: dictionary of sequences, keyed by vertices, with each value containing the neighbors of that vertex. Vertices do not have a attributecsi|]\}}||qSrrrArRrSrrrrssz._export_graph_to_list_dict..) r>rr"rr%r#rurr) rPrUrr rvr}rQr r rrr_export_graph_to_list_dicts"    r)rUr0rpr c s|dk rBt|tr|g}tt|t|}|rBtd||sl||krbtd|d|j|}tdd}|j D]f}|j \} } |s|| } || } | |dk r‡fdd|D|rd d D|| | <q~d d| D}|S) aZExport graph to dictionary of dicts of edge attributes This function is the reverse of Graph.DictDict. Example: >>> g = Graph.Full(3) >>> g.es['name'] = ['first_edge', 'second', 'third'] >>> g.to_dict_dict() {0: {1: {'name': 'first_edge'}, 2: {'name': 'second'}}, 1: {2: {'name': 'third'}}} @param use_vids: whether to label vertices in the output data structure by their ids or their vertex_name_attr attribute. If use_vids=False but vertices lack a vertex_name_attr attribute, an AttributeError is raised. @param edge_attrs: list of edge attributes to export. None (default) signified all attributes (unlike Graph.to_tuple_list). A string is acceptable to signify a single attribute and will be wrapped in a list internally. @param skip_none: whether to skip, for each edge, attributes that have a value of None. This is useful if only some edges are expected to possess an attribute. @param vertex_name_attr: only used with use_vids=False to choose what vertex attribute to use to name your vertices in the output data structure. @return: dictionary of dictionaries of dictionaries, with the outer keys vertex ids/names, the middle keys ids/names of their neighbors, and the innermost dictionary representing attributes of that edge. NryrrcSsttSr)rdictrrrrz,_export_graph_to_dict_dict..csi|]}||qSrr)rAr+rwrrrssz._export_graph_to_dict_dict..cSsi|]\}}|dk r||qSrrrrrrrrsscSsi|]\}}|t|qSr)rrrrrrss) r7r8r%r r;rr>r"rr#rurtr) rPrUr0rpr r~rvr}rQr r rrr_export_graph_to_dict_dicts0%      rcsbz ddl}Wntk r(tdYnX|jfddDttd}d|j_|S)aExport vertices with attributes to pandas.DataFrame If you want to use vertex names as index, you can do: >>> from string import ascii_letters >>> graph = Graph.GRG(25, 0.4) >>> graph.vs["name"] = ascii_letters[:graph.vcount()] >>> df = graph.get_vertex_dataframe() >>> df.set_index('name', inplace=True) @return: a pandas.DataFrame representing vertices and their attributes. The index uses vertex IDs, from 0 to N - 1 where N is the number of vertices. rNrVcsi|]}|j|qSr)r"rAattrrPrrrssz,_export_vertex_dataframe..rWz vertex ID) rXrYrcr>r%raZvcountr=rrPrkZdfrrr_export_vertex_dataframe s rcsz ddl}Wntk r(tdYnX|jfddDttd}d|j_|j ddd d j Dd d |j d ddd j Dd d |S)aExport edges with attributes to pandas.DataFrame If you want to use source and target vertex IDs as index, you can do: >>> from string import ascii_letters >>> graph = Graph.GRG(25, 0.4) >>> graph.vs["name"] = ascii_letters[:graph.vcount()] >>> df = graph.get_edge_dataframe() >>> df.set_index(['source', 'target'], inplace=True) The index will be a pandas.MultiIndex. You can use the C{drop=False} option to keep the C{source} and C{target} columns. If you want to use vertex names in the source and target columns: >>> df = graph.get_edge_dataframe() >>> df_vert = graph.get_vertex_dataframe() >>> df['source'].replace(df_vert['name'], inplace=True) >>> df['target'].replace(df_vert['name'], inplace=True) >>> df_vert.set_index('name', inplace=True) # Optional @return: a pandas.DataFrame representing edges and their attributes. The index uses edge IDs, from 0 to M - 1 where M is the number of edges. The first two columns of the dataframe represent the IDs of source and target vertices for each edge. These columns have names "source" and "target". If your edges have attributes with the same names, they will be present in the dataframe, but not in the first two columns. rNrVcsi|]}|j|qSr)r#rrrrrsKsz*_export_edge_dataframe..rWzedge IDr cSsg|] }|jqSr)r rAerrrr|Psz*_export_edge_dataframe..T)Zallow_duplicatesrr cSsg|] }|jqSr)r rrrrr|Qs) rXrYrcr;r%raZecountr=rinsertr#rrrr_export_edge_dataframe's r)Frr F)FrNF)Fr)Fr)TNT)TFr)TNr)TNFr)typingrr collectionsr itertoolsrwarningsrZigraph.datatypesrboolr8r4r?rNrTrorxrr%callablerrrrrrrrs      ^ @ J  J F 9 G