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`.`drawing``

package documentation
(source)

Drawing and plotting routines for igraph.

igraph has two stable plotting backends at the moment: Cairo and Matplotlib. It also has experimental support for plotly.

The Cairo backend is dependent on the `pycairo` or `cairocffi` libraries that provide Python bindings to the popular Cairo library. This means that if you don't have pycairo or cairocffi installed, you won't be able to use the Cairo plotting backend. Whenever the documentation refers to the `pycairo` library, you can safely replace it with `cairocffi` as the two are API-compatible.

The Matplotlib backend uses the Matplotlib library. You will need to install it from PyPI if you want to use the Matplotlib plotting backend. Many of our gallery examples use the matplotlib backend.

The plotly backend uses the plotly library and, like matplotlib, requires installation from PyPI.

If you do not want to (or cannot) install any of the dependencies outlined above, you can still save the graph to an SVG file and view it from Mozilla Firefox (free) or edit it in Inkscape (free), Skencil (formerly known as Sketch, also free) or Adobe Illustrator.

Module | `baseclasses` | Abstract base classes for the drawing routines.
Package | `cairo` | No package docstring; 10/13 modules documented
Module | `colors` | Color handling functions.
Module | `graph` | Drawing routines to draw graphs.
Package | `matplotlib` | No package docstring; 7/9 modules documented
Module | `metamagic` | Auxiliary classes for the default graph drawer in igraph.
Package | `plotly` | No package docstring; 3/5 modules documented
Module | `shapes` | Shape drawing classes for igraph
Module | `text` | Drawers for labels on plots.
Module | `utils` | Utility classes for drawing routines.

From `__init__.py`:

Class | `DrawerDirectory` | Static class that finds the object/backend drawer
Function | `plot` | Plots the given object to the given target.

def plot(obj, target=None, bbox=(0, 0, 600, 600), *args, **kwds): (source)

Plots the given object to the given target.

Positional and keyword arguments not explicitly mentioned here will be passed down to the `__plot__` method of the object being plotted. Since you are most likely interested in the keyword arguments available for graph plots, see `Graph.__plot__` as well.

Parameters
obj | the object to be plotted

target

the target where the object should be plotted. It can be one of the following types:

- `matplotib.axes.Axes` -- a matplotlib/pyplot axes in which the graph will be plotted. Drawing is delegated to the chosen matplotlib backend, and you can use interactive backends and matplotlib functions to save to file as well.
- `string` -- a file with the given name will be created and the plot will be stored there. If you are using the Cairo backend, an appropriate Cairo surface will be attached to the file. If you are using the matplotlib backend, the Figure will be saved to that file using Figure.savefig with default parameters. The supported image formats for Cairo are: PNG, PDF, SVG and PostScript; matplotlib might support additional formats.
- `cairo.Surface` -- the given Cairo surface will be used. This can refer to a PNG image, an arbitrary window, an SVG file, anything that Cairo can handle.
- `None` -- If you are using the Cairo backend, no plotting will be performed; igraph simply returns a CairoPlot_ object that you can use to manipulate the plot and save it to a file later. If you are using the matplotlib backend, a Figure objet and an Axes are created and the Axes is returned so you can manipulate it further. Similarly, if you are using the plotly backend, a Figure object is returned.

bbox

the bounding box of the plot. It must be a tuple with either two or four integers, or a `BoundingBox` object. If this is a tuple with two integers, it is interpreted as the width and height of the plot (in pixels for PNG images and on-screen plots, or in points for PDF, SVG and PostScript plots, where 72 pt = 1 inch = 2.54 cm). If this is a tuple with four integers, the first two denotes the X and Y coordinates of a corner and the latter two denoting the X and Y coordinates of the opposite corner. Ignored for Matplotlib plots.

*args | Undocumented
opacity | the opacity of the object being plotted. It can be used to overlap several plots of the same graph if you use the same layout for them -- for instance, you might plot a graph with opacity 0.5 and then plot its spanning tree over it with opacity 0.1. To achieve this, you'll need to modify the `Plot` object returned with `Plot.add`. Ignored for Matplotlib plots.
palette | the palette primarily used on the plot if the added objects do not specify a private palette. Must be either an `igraph.drawing.colors.Palette` object or a string referring to a valid key of `igraph.drawing.colors.palettes` (see module `igraph.drawing.colors`) or `None`. In the latter case, the default palette given by the configuration key `plotting.palette` is used.
margin | the top, right, bottom, left margins as a 4-tuple. If it has less than 4 elements or is a single float, the elements will be re-used until the length is at least 4. The default margin is 20 units on each side. Ignored for Matplotlib plots.
inline | whether to try and show the plot object inline in the current IPython notebook. Passing `None` here or omitting this keyword argument will look up the preferred behaviour from the `shell.ipython.inlining.Plot` configuration key. Note that this keyword argument has an effect only if igraph is run inside IPython and `target` is `None`.
backend | the plotting backend to use; one of `"cairo"`, `"matplotlib"` or `"plotly"`. `None` means to try to decide the backend from the plotting target and the default igraph configuration object.
Returns
an appropriate `CairoPlot` object for the Cairo backend, the Matplotlib `Axes` object for the Matplotlib backend, and the `Figure` object for the plotly backend.
See Also
Graph.__plot__