search in docstrings

Search bar offers the following options:

- Term presence. The below example searches for documents that must contain “foo”, might contain “bar” and must not contain “baz”: `+foo bar -baz`
- Wildcards. The below example searches for documents with words beginning with “foo”: `foo*`
- Search in specific fields. The following search matches all objects in "twisted.mail" that matches “search”: `+qname:twisted.mail.* +search`

  Possible fields: 'name', 'qname' (fully qualified name), 'docstring', and 'kind'. Last two fields are only applicable if "search in docstrings" is enabled.

- Fuzzy matches. The following search matches all documents that have a word within 1 edit distance of “foo”: `foo~1`

Results provided by Lunr.js

# ``igraph`.`layout``

module documentation
(source)

Layout-related code in the igraph library.

This package contains the implementation of the `Layout` object.

Class | `Layout` | Represents the layout of a graph.
Function | `_3d_version_for` | Creates an alias for the 3D version of the given layout algoritm.
Function | `_layout` | Returns the layout of the graph according to a layout algorithm.
Function | `_layout_auto` | Chooses and runs a suitable layout function based on simple topological properties of the graph.
Function | `_layout_method_wrapper` | Wraps an existing layout method to ensure that it returns a Layout instead of a list of lists.
Function | `_layout_sugiyama` | Places the vertices using a layered Sugiyama layout.
Variable | `_layout_mapping` | Undocumented

def _3d_version_for(func): (source)

Creates an alias for the 3D version of the given layout algoritm.

This function is a decorator that creates a method which calls func after attaching `dim=3` to the list of keyword arguments.

Parameters
func | must be a method of the Graph object.
Returns
a new method

def _layout(graph, layout=None, *args, **kwds): (source)

Returns the layout of the graph according to a layout algorithm.

Parameters and keyword arguments not specified here are passed to the layout algorithm directly. See the documentation of the layout algorithms for the explanation of these parameters.

Registered layout names understood by this method are:

- `auto`, `automatic`: automatic layout (see `Graph.layout_auto`)
- `bipartite`: bipartite layout (see `GraphBase.layout_bipartite`)
- `circle`, `circular`: circular layout (see `GraphBase.layout_circle`)
- `dh`, `davidson_harel`: Davidson-Harel layout (see `GraphBase.layout_davidson_harel`)
- `drl`: DrL layout for large graphs (see `GraphBase.layout_drl`)
- `drl_3d`: 3D DrL layout for large graphs (see `GraphBase.layout_drl`)
- `fr`, `fruchterman_reingold`: Fruchterman-Reingold layout (see `GraphBase.layout_fruchterman_reingold`).
- `fr_3d`, `fr3d`, `fruchterman_reingold_3d`: 3D Fruchterman- Reingold layout (see `GraphBase.layout_fruchterman_reingold`).
- `grid`: regular grid layout in 2D (see `GraphBase.layout_grid`)
- `grid_3d`: regular grid layout in 3D (see `GraphBase.layout_grid`)
- `graphopt`: the graphopt algorithm (see `GraphBase.layout_graphopt`)
- `kk`, `kamada_kawai`: Kamada-Kawai layout (see `GraphBase.layout_kamada_kawai`)
- `kk_3d`, `kk3d`, `kamada_kawai_3d`: 3D Kamada-Kawai layout (see `GraphBase.layout_kamada_kawai`)
- `lgl`, `large`, `large_graph`: Large Graph Layout (see `GraphBase.layout_lgl`)
- `mds`: multidimensional scaling layout (see `GraphBase.layout_mds`)
- `random`: random layout (see `GraphBase.layout_random`)
- `random_3d`: random 3D layout (see `GraphBase.layout_random`)
- `rt`, `tree`, `reingold_tilford`: Reingold-Tilford tree layout (see `GraphBase.layout_reingold_tilford`)
- `rt_circular`, `reingold_tilford_circular`: circular Reingold-Tilford tree layout (see `GraphBase.layout_reingold_tilford_circular`)
- `sphere`, `spherical`, `circle_3d`, `circular_3d`: spherical layout (see `GraphBase.layout_circle`)
- `star`: star layout (see `GraphBase.layout_star`)
- `sugiyama`: Sugiyama layout (see `Graph.layout_sugiyama`)

Parameters
graph | Undocumented
layout | the layout to use. This can be one of the registered layout names or a callable which returns either a `Layout` object or a list of lists containing the coordinates. If `None`, uses the value of the `plotting.layout` configuration key.
*args | Undocumented
**kwds | Undocumented
Returns
a `Layout` object.

def _layout_auto(graph, *args, **kwds): (source)

Chooses and runs a suitable layout function based on simple topological properties of the graph.

This function tries to choose an appropriate layout function for the graph using the following rules:

1. If the graph has an attribute called `layout`, it will be used. It may either be a `Layout` instance, a list of coordinate pairs, the name of a layout function, or a callable function which generates the layout when called with the graph as a parameter.
2. Otherwise, if the graph has vertex attributes called `x` and `y`, these will be used as coordinates in the layout. When a 3D layout is requested (by setting `dim` to 3), a vertex attribute named `z` will also be needed.
3. Otherwise, if the graph is connected and has at most 100 vertices, the Kamada-Kawai layout will be used (see `GraphBase.layout_kamada_kawai()`).
4. Otherwise, if the graph has at most 1000 vertices, the Fruchterman-Reingold layout will be used (see `GraphBase.layout_fruchterman_reingold()`).
5. If everything else above failed, the DrL layout algorithm will be used (see `GraphBase.layout_drl()`).

All the arguments of this function except `dim` are passed on to the chosen layout function (in case we have to call some layout function).

Parameters
graph | Undocumented
*args | Undocumented
dim | specifies whether we would like to obtain a 2D or a 3D layout.
Returns
a `Layout` object.

def _layout_method_wrapper(func): (source)

Wraps an existing layout method to ensure that it returns a Layout instead of a list of lists.

Parameters
func | the method to wrap. Must be a method of the Graph object.
Returns
a new method

def _layout_sugiyama(graph, layers=None, weights=None, hgap=1, vgap=1, maxiter=100, return_extended_graph=False): (source)

Places the vertices using a layered Sugiyama layout.

This is a layered layout that is most suitable for directed acyclic graphs, although it works on undirected or cyclic graphs as well.

Each vertex is assigned to a layer and each layer is placed on a horizontal line. Vertices within the same layer are then permuted using the barycenter heuristic that tries to minimize edge crossings.

Dummy vertices will be added on edges that span more than one layer. The returned layout therefore contains more rows than the number of nodes in the original graph; the extra rows correspond to the dummy vertices.

References:

- K Sugiyama, S Tagawa, M Toda: Methods for visual understanding of hierarchical system structures. IEEE Systems, Man and Cybernetics 11(2):109-125, 1981.
- P Eades, X Lin and WF Smyth: A fast effective heuristic for the feedback arc set problem. Information Processing Letters 47:319-323, 1993.

Parameters
graph | Undocumented

layers

a vector specifying a non-negative integer layer index for each vertex, or the name of a numeric vertex attribute that contains the layer indices. If `None`, a layering will be determined automatically. For undirected graphs, a spanning tree will be extracted and vertices will be assigned to layers using a breadth first search from the node with the largest degree. For directed graphs, cycles are broken by reversing the direction of edges in an approximate feedback arc set using the heuristic of Eades, Lin and Smyth, and then using longest path layering to place the vertices in layers.

weights | edge weights to be used. Can be a sequence or iterable or even an edge attribute name.
hgap | minimum horizontal gap between vertices in the same layer.
vgap | vertical gap between layers. The layer index will be multiplied by vgap to obtain the Y coordinate.
maxiter | maximum number of iterations to take in the crossing reduction step. Increase this if you feel that you are getting too many edge crossings.

return_extended_graph

specifies that the extended graph with the added dummy vertices should also be returned. When this is `True`, the result will be a tuple containing the layout and the extended graph. The first |V| nodes of the extended graph will correspond to the nodes of the original graph, the remaining ones are dummy nodes. Plotting the extended graph with the returned layout and hidden dummy nodes will produce a layout that is similar to the original graph, but with the added edge bends. The extended graph also contains an edge attribute called `_original_eid` which specifies the ID of the edge in the original graph from which the edge of the extended graph was created.

Returns
the calculated layout, which may (and usually will) have more rows than the number of vertices; the remaining rows correspond to the dummy nodes introduced in the layering step. When `return_extended_graph` is `True`, it will also contain the extended graph.

_layout_mapping: `dict[str, str]` = (source)

Undocumented