PyGraphviz

https://pygraphviz.github.io/documentation/latest/
Admin
PyGraphviz is a Python interface to Graphviz that enables creating, editing, reading, writing, and...
Tokens:41,890
Snippets:315
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Programmatic graph creation and drawing with PyGraphviz

Source: https://pygraphviz.github.io/documentation/latest/auto_examples/plot_simple.html

This example demonstrates how to create a graph, add edges, and then render it to a file using PyGraphviz. It requires the pygraphviz library to be installed. The graph is saved as a DOT file and then drawn as a PNG image.

```python
#    Copyright (C) 2006 by
#    Aric Hagberg <hagberg@lanl.gov>
#    Dan Schult <dschult@colgate.edu>
#    Manos Renieris, http://www.cs.brown.edu/~er/
#    Distributed with BSD license.
#    All rights reserved, see LICENSE for details.

__author__ = """Aric Hagberg (hagberg@lanl.gov)"""

import pygraphviz as pgv

A = pgv.AGraph()

A.add_edge(1, 2)
A.add_edge(2, 3)
A.add_edge(1, 3)

print(A.string())  # print to screen
A.write("simple.dot")  # write to simple.dot

B = pgv.AGraph("simple.dot")  # create a new graph from file
B.layout()  # layout with default (neato)
B.draw("simple.png")  # draw png

```

--------------------------------

### Set Up Development Environment

Source: https://pygraphviz.github.io/documentation/latest/developer/contribute.html

Commands to create a virtual environment, install dependencies, and install the package in editable mode.

```bash
# Create a virtualenv named ``pygraphviz-dev`` that lives in the directory of
# the same name
python -m venv pygraphviz-dev
# Activate it
source pygraphviz-dev/bin/activate
# Install main development and runtime dependencies of pygraphviz
pip install -r requirements/test.txt -r requirements/developer.txt
#
# Build and install pygraphviz from source
pip install -e .
# Test your installation
PYTHONPATH=. pytest pygraphviz
```

--------------------------------

### Run Tests with Setuptools

Source: https://pygraphviz.github.io/documentation/latest/release/old_release_log.html

If setuptools is installed, run the library's tests using the command `python setup_egg.py test`. This is useful for verifying installation and functionality.

```bash
python setup_egg.py test
```

--------------------------------

### Install Pre-commit Hook

Source: https://pygraphviz.github.io/documentation/latest/developer/contribute.html

Installs the pre-commit hook to automatically run black during commits.

```bash
pre-commit install
```

--------------------------------

### Install Graphviz and PyGraphviz on macOS with Homebrew

Source: https://pygraphviz.github.io/documentation/latest/install.html

Install Graphviz using Homebrew and PyGraphviz using pip on macOS.

```bash
$ brew install graphviz
$ pip install pygraphviz

```

--------------------------------

### Install Graphviz and PyGraphviz on Ubuntu/Debian

Source: https://pygraphviz.github.io/documentation/latest/install.html

Install Graphviz development files and PyGraphviz using apt-get and pip on Ubuntu and Debian-based systems.

```bash
$ sudo apt-get install graphviz graphviz-dev
$ pip install pygraphviz

```

--------------------------------

### Install PyGraphviz on Windows with Manual Graphviz Path

Source: https://pygraphviz.github.io/documentation/latest/install.html

Install PyGraphviz on Windows by manually specifying the Graphviz include and library paths in the pip installation command.

```powershell
PS C:\> python -m pip install --config-settings="--global-option=build_ext" \
              --config-settings="--global-option=-IC:\Program Files\Graphviz\include" \
              --config-settings="--global-option=-LC:\Program Files\Graphviz\lib" \
              pygraphviz

```

--------------------------------

### Install PyGraphviz on Windows with Chocolatey

Source: https://pygraphviz.github.io/documentation/latest/install.html

Install Graphviz using Chocolatey and then install PyGraphviz, specifying Graphviz paths if necessary.

```powershell
PS C:\> choco install graphviz
PS C:\> python -m pip install --config-settings="--global-option=build_ext" \
              --config-settings="--global-option=-IC:\Program Files\Graphviz\include" \
              --config-settings="--global-option=-LC:\Program Files\Graphviz\lib" \
              pygraphviz

```

--------------------------------

### Install PyGraphviz with Custom Graphviz Path

Source: https://pygraphviz.github.io/documentation/latest/reference/faq.html

Use this command to install PyGraphviz when the Graphviz libraries are not in the default system path. The -L and -R flags specify the library search paths for build and run time, respectively.

```bash
pip install --config-settings="--global-option=build_ext" \
            --config-settings="--global-option=-L/opt/lib/mygviz/" \
            --config-settings="--global-option=-R/opt/lib/mygviz/" \
            pygraphviz
```

--------------------------------

### Install Graphviz and PyGraphviz on macOS with MacPorts

Source: https://pygraphviz.github.io/documentation/latest/install.html

Install Graphviz using MacPorts and PyGraphviz using pip, manually specifying paths if necessary.

```bash
$ port install graphviz
$ pip install pygraphviz
$ pip install --config-settings="--global-option=build_ext" \
              --config-settings="--global-option=-I/opt/local/include/" \
              --config-settings="--global-option=-L/opt/local/lib/" \
              pygraphviz

```

--------------------------------

### Install Graphviz and PyGraphviz on Fedora/Red Hat

Source: https://pygraphviz.github.io/documentation/latest/install.html

Install Graphviz development files and PyGraphviz using dnf (or yum) and pip on Fedora and Red Hat-based systems.

```bash
$ sudo dnf install graphviz graphviz-devel
$ pip install pygraphviz

```

--------------------------------

### Run Graphviz Programs

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Example of invoking external Graphviz layout or processing tools.

```python
>>> import pygraphviz as pgv
>>> A = pgv.AGraph()
```

--------------------------------

### Render graphs with AGraph.draw

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Examples demonstrating how to initialize a graph, perform a layout, and render it to a file using different formats and layout engines.

```python
>>> import pygraphviz as pgv
>>> G = pgv.AGraph()
>>> G.add_edges_from([(0, 1), (1, 2), (2, 0), (2, 3)])
>>> G.layout()

# use current node positions, output pdf in 'file.pdf'
>>> G.draw("file.pdf")

# use dot to position, output png in 'file'
>>> G.draw("file", format="png", prog="dot")

# use keyword 'args' to pass additional arguments to graphviz
>>> G.draw("test.pdf", prog="twopi", args="-Gepsilon=1")
>>> G.draw("test2.pdf", args="-Nshape=box -Edir=forward -Ecolor=red ")
```

--------------------------------

### Generate SWIG Wrappers

Source: https://pygraphviz.github.io/documentation/latest/developer/contribute.html

Generate SWIG wrappers for the graphviz C code by running the SWIG command on the 'graphviz.i' file. This requires SWIG to be installed and should be run from the top-level directory.

```bash
swig -python pygraphviz/graphviz.i

```

--------------------------------

### Install PyGraphviz with Conda

Source: https://pygraphviz.github.io/documentation/latest/install.html

Use the conda-forge channel for installing pygraphviz with conda to avoid issues with default channels.

```bash
conda install --channel conda-forge pygraphviz

```

--------------------------------

### Manually Specify Graphviz Path for PyGraphviz Installation (macOS Homebrew)

Source: https://pygraphviz.github.io/documentation/latest/install.html

When Graphviz is installed in a non-default location via Homebrew, manually specify include and library paths during pip installation.

```bash
pip install --config-settings="--global-option=build_ext" \
            --config-settings="--global-option=-I$(brew --prefix graphviz)/include/" \
            --config-settings="--global-option=-L$(brew --prefix graphviz)/lib/" \
            pygraphviz

```

--------------------------------

### Test Coverage Report Example

Source: https://pygraphviz.github.io/documentation/latest/developer/contribute.html

Example of a test coverage report generated by pytest. It shows statement counts, missed statements, and coverage percentage for each file.

```text
Name                     Stmts   Miss  Cover
--------------------------------------------
pygraphviz/__init__.py      12      4    67%
pygraphviz/agraph.py      1022    196    81%
pygraphviz/graphviz.py     179     42    77%
pygraphviz/scraper.py       26     18    31%
pygraphviz/testing.py       16      0   100%
--------------------------------------------
TOTAL                     1255    260    79%


```

--------------------------------

### Set release environment variables

Source: https://pygraphviz.github.io/documentation/latest/developer/release.html

Define shell variables for the current version, previous version, and repository details before starting the release process.

```bash
export VERSION=<version number>
export PREVIOUS=<previous version number>
export ORG="pygraphviz"
export REPO="pygraphviz"
```

--------------------------------

### Initialize Item Attributes

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Demonstrates how to set attributes for individual nodes and edges.

```python
>>> import pygraphviz as pgv
>>> G = pgv.AGraph()
>>> G.add_edge("a", "b")
>>> n = pgv.Node(G, "a")
>>> n.attr["shape"] = "circle"
>>> e = pgv.Edge(G, "a", "b")
>>> e.attr["color"] = "red"
```

--------------------------------

### Create and Draw a Graph with PyGraphviz

Source: https://pygraphviz.github.io/documentation/latest/_downloads/51891f3e62ffa1afbb2166aec79de121/plot_simple.ipynb

This snippet demonstrates the fundamental usage of PyGraphviz to create a graph, add edges, and then output it to both a string and a file. It also shows how to load a graph from a file and render it.

```python
#    Copyright (C) 2006 by
#    Aric Hagberg <hagberg@lanl.gov>
#    Dan Schult <dschult@colgate.edu>
#    Manos Renieris, http://www.cs.brown.edu/~er/
#    Distributed with BSD license.
#    All rights reserved, see LICENSE for details.

__author__ = """Aric Hagberg (hagberg@lanl.gov)"""

import pygraphviz as pgv

A = pgv.AGraph()

A.add_edge(1, 2)
A.add_edge(2, 3)
A.add_edge(1, 3)

print(A.string())  # print to screen
A.write("simple.dot")  # write to simple.dot

B = pgv.AGraph("simple.dot")  # create a new graph from file
B.layout()  # layout with default (neato)
B.draw("simple.png")  # draw png
```

--------------------------------

### Clone and Configure Repository

Source: https://pygraphviz.github.io/documentation/latest/developer/contribute.html

Commands to clone the repository and add the upstream remote for tracking changes.

```bash
git clone git@github.com:your-username/pygraphviz.git
```

```bash
git remote add upstream git@github.com:pygraphviz/pygraphviz.git
```

--------------------------------

### Initialize AGraph from Dictionary

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Demonstrates initializing an AGraph from a dictionary representing graph structure, and then converting it to a string and back.

```python
>>> d = {"1": {"2": None}, "2": {"1": None, "3": None}, "3": {"2": None}}
>>> A = pgv.AGraph(d)
>>> s = A.to_string()
>>> B = pgv.AGraph(s)
>>> h = B.handle
>>> C = pgv.AGraph(h)
```

--------------------------------

### Get Graph Name

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Retrieves the name of the graph.

```APIDOC
## Get Graph Name

### Description
Retrieves the name of the graph, decoded using the graph's encoding.

### Method
`get_name(self)`

### Endpoint
N/A (Instance method)

### Response
- **str**: The name of the graph, or None if it has no name.

## Name Property

### Description
A property to access the graph's name.

### Method
`name` (property)

### Response
- **str**: The name of the graph.
```

--------------------------------

### Commit release changes

Source: https://pygraphviz.github.io/documentation/latest/developer/release.html

Stage updated documentation and version files, run pre-commit hooks, and commit the changes.

```bash
git add doc/source/release/index.rst ${NOTES}
git add pygraphviz/__init__.py doc/source/_static/version_switcher.json
pre-commit run -a
git commit -m "Designate ${VERSION} release"
```

--------------------------------

### Get Edge

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Retrieves a specific edge object from the graph.

```APIDOC
## GET /api/graph/{graph_id}/edges

### Description
Retrieves a specific edge object from the graph. If a key is provided, it will match the edge with that specific key.

### Method
GET

### Endpoint
/api/graph/{graph_id}/edges

### Parameters
#### Path Parameters
- **graph_id** (string) - Required - The unique identifier of the graph.

#### Query Parameters
- **u** (string) - Required - The source node of the edge.
- **v** (string) - Required - The target node of the edge.
- **key** (string) - Optional - The key of the edge to retrieve.

### Response
#### Success Response (200)
- **edge** (object) - An object representing the edge, typically containing its endpoints and attributes.

#### Response Example
```json
{
  "edge": {
    "u": "a",
    "v": "b",
    "key": "first",
    "attributes": {
      "color": "green"
    }
  }
}
```
```

--------------------------------

### Run Tests

Source: https://pygraphviz.github.io/documentation/latest/developer/contribute.html

Executes the test suite locally to verify changes.

```bash
PYTHONPATH=. pytest pygraphviz
```

--------------------------------

### Get Number of Edges

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Returns the total number of edges in the graph.

```python
return gv.agnedges(self.handle)
```

--------------------------------

### Node Neighbors

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Provides methods to get neighbors of a node and iterate over them.

```APIDOC
## neighbors(self, n)

### Description
Return a list of the nodes attached to n.

### Method
GET (conceptual)

### Endpoint
N/A (Method within a class)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
# Assuming 'graph' is a PyGraphviz graph object and 'node_id' is a node identifier
neighbors_list = graph.neighbors(node_id)
```

### Response
#### Success Response (200)
- **list** - A list of nodes attached to the specified node.

#### Response Example
```json
{
  "example": "[node1, node2, ... ]"
}
```
```

```APIDOC
## iterneighbors(self, n)

### Description
Alias for `neighbors_iter`. Returns an iterator over the neighbors of a node.

### Method
GET (conceptual)

### Endpoint
N/A (Method within a class)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
# Assuming 'graph' is a PyGraphviz graph object and 'node_id' is a node identifier
for neighbor in graph.iterneighbors(node_id):
    print(neighbor)
```

### Response
#### Success Response (200)
- **iterator** - An iterator yielding nodes attached to the specified node.

#### Response Example
```json
{
  "example": "iterator object"
}
```
```

--------------------------------

### Graph Name Property

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Provides a property interface to get the graph's name.

```python
name = property(get_name)
```

--------------------------------

### AGraph Class Initialization

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Demonstrates various ways to initialize an AGraph object, including from a filename, string, dictionary, or by specifying graph attributes.

```APIDOC
## AGraph Class Initialization

### Description
Initializes an AGraph object. It can accept various input types for graph data and allows setting graph attributes during initialization.

### Parameters
- **thing** (any) - Generic input type (filename, string, handle, dictionary of dictionaries). Type is auto-detected.
- **filename** (str) - Path to a DOT file to load.
- **data** (dict) - Dictionary of dictionaries or lists representing nodes or edges.
- **string** (str) - String containing graph data in DOT format.
- **handle** (Swig pointer) - Pointer to an agraph_t data structure.
- **name** (str) - Name for the graph.
- **strict** (bool) - True for simple graphs, False otherwise.
- **directed** (bool) - True for directed graphs, False otherwise.
- **&& attr** (dict) - Keyword parameters for graph attributes.

### Request Example
```python
import pygraphviz as pgv

# Initialize an empty graph
G = pgv.AGraph()

# Initialize a directed graph
G_directed = pgv.AGraph(directed=True)

# Initialize from a DOT file
G_from_file = pgv.AGraph("file.dot")

# Initialize with graph attributes
G_attrs = pgv.AGraph(landscape="true", ranksep="0.1")

# Initialize from a dictionary
d = {"1": {"2": None}, "2": {"1": None, "3": None}, "3": {"2": None}}
A = pgv.AGraph(d)

# Initialize from a string
s = A.to_string()
B = pgv.AGraph(s)

# Initialize from a handle
h = B.handle
C = pgv.AGraph(h)
```
```

--------------------------------

### Create and Configure Graph with PyGraphviz

Source: https://pygraphviz.github.io/documentation/latest/auto_examples/plot_attributes.html

Use this Python code to programmatically create a directed graph with attributes, add nodes and edges with specific styling, and then render it to a file. Requires PyGraphviz library.

```python
import pygraphviz as pgv

# strict (no parallel edges)
# digraph
# with attribute rankdir set to 'LR'
A = pgv.AGraph(directed=True, strict=True, rankdir="LR")
# add node 1 with color red
A.add_node(1, color="red")
A.add_node(5, color="blue")
# add some edges
A.add_edge(1, 2, color="green")
A.add_edge(2, 3)
A.add_edge(1, 3)
A.add_edge(3, 4)
A.add_edge(3, 5)
A.add_edge(3, 6)
A.add_edge(4, 6)
# adjust a graph parameter
A.graph_attr["epsilon"] = "0.001"
print(A.string())  # print dot file to standard output
A.layout("dot")  # layout with dot
A.draw("foo.png")  # write to file

```

--------------------------------

### Get or iterate over subgraphs

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Methods to retrieve a specific subgraph by name or iterate through all subgraphs in the graph.

```python
    def get_subgraph(self, name):
        """Return existing subgraph with specified name or None if it
        doesn't exist.
        """
        try:
            handle = gv.agsubg(self.handle, name.encode(self.encoding), _Action.find)
        except TypeError:
            raise TypeError(f"Subgraph name must be a string: {name}")

        if handle is None:
            return None
        H = self.__class__(strict=self.strict, directed=self.directed, handle=handle)
        return H
```

```python
    def subgraphs_iter(self):
        """Iterator over subgraphs."""
        handle = gv.agfstsubg(self.handle)
        while handle is not None:
            yield self.__class__(
                strict=self.strict, directed=self.directed, handle=handle
            )
            try:
                handle = gv.agnxtsubg(handle)
            except StopIteration:
                return
```

```python
    def subgraphs(self):
        """Return a list of all subgraphs in the graph."""
        return list(self.subgraphs_iter())
```

--------------------------------

### Get the number of nodes in a graph

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

The `number_of_nodes` method returns the total count of nodes in the graph.

```python
return gv.agnnodes(self.handle)
```

--------------------------------

### Get a list of all nodes in a graph

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

The `nodes` method returns a list containing all nodes currently in the graph.

```python
return list(self.nodes_iter())
```

--------------------------------

### Initialize AGraph with basic parameters

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Create a new AGraph instance, specifying basic properties like name, strictness, and directedness.

```python
>>> import pygraphviz as pgv
>>> G = pgv.AGraph()
>>> G = pgv.AGraph(directed=True)
```

--------------------------------

### Get Graphviz Attribute

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Retrieves an attribute value from a Graphviz object. Decodes the value from bytes to a UTF-8 string if it exists.

```python
def __getitem__(self, name):
        val = gv.agget(self.handle, name.encode(self.encoding))
        if val is not None:
            val = val.decode(self.encoding)
        return val
```

--------------------------------

### Tag the release

Source: https://pygraphviz.github.io/documentation/latest/developer/release.html

Create a signed git tag for the new release version.

```bash
git tag -s pygraphviz-${VERSION} -m "signed ${VERSION} tag"
```

--------------------------------

### Bump version after release

Source: https://pygraphviz.github.io/documentation/latest/developer/release.html

Update the version in the init file and push the changes to the main branch.

```bash
git add pygraphviz/__init__.py
git commit -m 'Bump version'
git push origin main
```

--------------------------------

### Get List of Predecessor Nodes

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Returns a list of all predecessor nodes for a given node `n`. Use `predecessors_iter` for an iterator.

```python
def predecessors(self, n):
        """Return list of predecessor nodes of n."""
        return list(self.predecessors_iter(n))
```

--------------------------------

### Set Node, Edge, and Graph Attributes

Source: https://pygraphviz.github.io/documentation/latest/_downloads/8d1b42cb8500b07a1ffe1d61d124333a/plot_attributes.ipynb

Illustrates creating a directed graph, adding nodes with specific colors, defining edges with attributes, and setting graph-level parameters. Use this to customize graph visualizations.

```python
import pygraphviz as pgv

# strict (no parallel edges)
# digraph
# with attribute rankdir set to 'LR'
A = pgv.AGraph(directed=True, strict=True, rankdir="LR")
# add node 1 with color red
A.add_node(1, color="red")
A.add_node(5, color="blue")
# add some edges
A.add_edge(1, 2, color="green")
A.add_edge(2, 3)
A.add_edge(1, 3)
A.add_edge(3, 4)
A.add_edge(3, 5)
A.add_edge(3, 6)
A.add_edge(4, 6)
# adjust a graph parameter
A.graph_attr["epsilon"] = "0.001"
print(A.string())  # print dot file to standard output
A.layout("dot")  # layout with dot
A.draw("foo.png")  # write to file
```

--------------------------------

### Get List of Successor Nodes

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Returns a list of all successor nodes for a given node `n`. Use `successors_iter` for an iterator.

```python
def successors(self, n):
        """Return list of successor nodes of n."""
        return list(self.successors_iter(n))
```

--------------------------------

### Initialize AGraph with Attributes

Source: https://pygraphviz.github.io/documentation/latest/release/old_release_log.html

Demonstrates initializing an AGraph object with attributes and adding nodes and edges with their own attributes. Attributes known to Graphviz are used for drawing and layout.

```python
A=AGraph(ranksep='0.1'); A.add_node('a',color='red') A.add_edge('a','b',color='blue')
```

--------------------------------

### Get List of Incoming Edges

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Returns a list of all incoming edges to the graph or specified nodes. Use `in_edges_iter` for an iterator.

```python
def in_edges(self, nbunch=None, keys=False):
        """Return list of in edges in the graph.
        If the optional nbunch (container of nodes) only in edges
        adjacent to nodes in nbunch will be returned.
        """
        return list(self.in_edges_iter(nbunch=nbunch, keys=keys))
```

--------------------------------

### Initialize Graph with Encoding and Attributes

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Handles graph initialization, setting encoding from 'charset' attribute or kwargs, and populating the graph with initial data. It also assigns graph, node, and edge attributes.

```python
            # the handle was specified or created
            # get the encoding from the "charset" graph attribute
            item = gv.agget(self.handle, b"charset")
            if item is not None:
                self.encoding = (
                    item if type(item) is not bytes else item.decode("utf-8")
                )
            else:
                self.encoding = _DEFAULT_ENCODING
        else:
            # no handle was specified or created
            # get encoding from the "charset" kwarg
            self.encoding = attr.get("charset", _DEFAULT_ENCODING)
            try:
                if name is None:
                    name = ""
                    # instantiate a new, empty graph
                self.handle = gv.agraphnew(name.encode(self.encoding), strict, directed)
            except TypeError:
                raise TypeError(f"Graph name must be a string: {name}")

            # encoding is already set but if it was specified explicitly
            # as an attr, then set it explicitly for the graph
            if "charset" in attr:
                gv.agattr_label(self.handle, 0, "charset", self.encoding)

            # if data is specified, populate the newly created graph
            if data is not None:
                # load from dict of dicts or dict of lists
                for node in data:
                    for nbr in data[node]:
                        self.add_edge(node, nbr)
                self.add_nodes_from(data.keys())

        # throw away the charset attribute, if one exists,
        # since we've already set it, and now it should not be changed
        if "charset" in attr:
            del attr["charset"]

        # assign any attributes specified through keywords
        self.graph_attr = Attribute(self.handle, 0)  # graph attributes
        self.graph_attr.update(attr)  # apply attributes passed to init
        self.node_attr = Attribute(self.handle, 1)  # default node attributes
        self.edge_attr = Attribute(self.handle, 2)  # default edge attribtes
```

--------------------------------

### Get List of Outgoing Edges

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Returns a list of all outgoing edges from the graph or specified nodes. Use `out_edges_iter` for an iterator.

```python
def out_edges(self, nbunch=None, keys=False):
        """Return list of out edges in the graph.

        If the optional nbunch (container of nodes) only out edges
        adjacent to nodes in nbunch will be returned.
        """
        return list(self.out_edges_iter(nbunch=nbunch, keys=keys))
```

--------------------------------

### Get Node Object

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Retrieves a node object from the graph by its identifier. The `in` operator can also be used for checking node existence.

```python
>>> import pygraphviz as pgv
>>> G = pgv.AGraph()
>>> G.add_node("a")
>>> node = G.get_node("a")
>>> print(node)
a
```

--------------------------------

### Add and Print Edges

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Demonstrates how to add edges to a graph and then retrieve and print them. Use `sorted()` for consistent output.

```python
>>> import pygraphviz as pgv
>>> G = pgv.AGraph()
>>> G.add_edge("a", "b")
>>> G.add_edge("c", "d")
>>> print(sorted(G.edges()))
[('a', 'b'), ('c', 'd')]
>>> print(G.edges("a"))
[('a', 'b')]
```

--------------------------------

### Get Out-Degree of Nodes

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Returns the out-degree of nodes specified in `nbunch`. If `with_labels` is True, returns a dictionary mapping nodes to their out-degrees.

```python
def out_degree(self, nbunch=None, with_labels=False):
        """Return the out-degree of nodes given in nbunch container.

        Using optional with_labels=True returns a dictionary
        keyed by node with value set to the degree.
        
```

--------------------------------

### Initialize Graph Attributes

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Demonstrates how to set default attributes for graphs, nodes, and edges using the AGraph class.

```python
>>> import pygraphviz as pgv
>>> G = pgv.AGraph()  # initialize, G.graph_attr, G.node_attr, G.edge_attr
>>> G.graph_attr["splines"] = "true"
>>> G.node_attr["shape"] = "circle"
>>> G.edge_attr["color"] = "red"
```

--------------------------------

### Import PyGraphviz

Source: https://pygraphviz.github.io/documentation/latest/reference/faq.html

This is the standard import statement for PyGraphviz. If you encounter an ImportError, it likely means the Graphviz library is not correctly installed or its path is not configured.

```python
import pygraphviz
```

--------------------------------

### Autogenerate release notes

Source: https://pygraphviz.github.io/documentation/latest/developer/release.html

Use the changelist tool to generate release notes in both reStructuredText and Markdown formats.

```bash
changelist ${ORG}/${REPO}  pygraphviz-${PREVIOUS} main --version ${VERSION}  --out ${NOTES} --format rst
changelist ${ORG}/${REPO}  pygraphviz-${PREVIOUS} main --version ${VERSION} --out ${VERSION}.md
```

--------------------------------

### Create a simple DOT graph

Source: https://pygraphviz.github.io/documentation/latest/auto_examples/plot_simple.html

This snippet shows the basic DOT language syntax for defining a graph with nodes and edges. It's useful for understanding the fundamental structure of Graphviz graphs.

```dot
strict graph "" {
        node [label="\N"];
        1 -- 2;
        1 -- 3;
        2 -- 3;
}
```

--------------------------------

### Get Graph Name

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Retrieves the name of the graph from its handle, decoding it using the graph's encoding. Returns None if the name cannot be retrieved.

```python
    def get_name(self):
        name = gv.agnameof(self.handle)
        if name is not None:
            name = name.decode(self.encoding)
        return name
```

--------------------------------

### Initialize AGraph Class

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Demonstrates different ways to initialize an AGraph object. You can create an empty graph, specify it as directed, or initialize it from a DOT file.

```python
>>> import pygraphviz as pgv
>>> G = pgv.AGraph()
>>> G = pgv.AGraph(directed=True)
>>> G = pgv.AGraph("file.dot")
```

--------------------------------

### Graph Drawing with Arguments

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Demonstrates how to pass additional arguments to the Graphviz layout engine during drawing.

```APIDOC
## Graph Drawing with Arguments

### Description
Use the `args` keyword to pass additional arguments to Graphviz during the drawing process. This allows for fine-grained control over layout and rendering.

### Example Usage
```python
>>> import pygraphviz as pgv
>>> G = pgv.AGraph()
>>> G.draw("test.pdf", prog="twopi", args="-Gepsilon=1")
>>> G.draw("test2.pdf", args="-Nshape=box -Edir=forward -Ecolor=red ")
```

Note: The layout might take a long time on large graphs.
```

--------------------------------

### Get Edge Object

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Retrieves a specific edge object from the graph using its source and destination nodes. An optional key can be used for graphs with multiple edges between the same nodes.

```python
>>> import pygraphviz as pgv
>>> G = pgv.AGraph()
>>> G.add_edge("a", "b")
>>> edge = G.get_edge("a", "b")
>>> print(edge)
('a', 'b')
```

--------------------------------

### Review GitHub release page

Source: https://pygraphviz.github.io/documentation/latest/developer/release.html

URL to verify the tags on the GitHub repository.

```text
https://github.com/pygraphviz/pygraphviz/tags
```

--------------------------------

### Run All Tests and Doctests

Source: https://pygraphviz.github.io/documentation/latest/developer/contribute.html

Execute all PyGraphviz tests and doctests using pytest with the --doctest-modules flag. Ensure PYTHONPATH is set.

```bash
$ PYTHONPATH=. pytest --doctest-modules pygraphviz

```

--------------------------------

### Graph Initialization and Attributes

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Details on how graphs are initialized, including handling of encoding, graph attributes, and initial data population.

```APIDOC
## Graph Initialization

### Description
Initializes a new graph object. It handles encoding based on the 'charset' attribute or a default. If a name is provided, a new graph handle is created. Optionally, initial data can be loaded from a dictionary.

### Method
`__init__(self, name=None, strict=False, directed=True, efile=None, encoding=None, **attr)`

### Parameters
- **name** (str, optional): The name of the graph.
- **strict** (bool, optional): If True, creates a strict graph (no parallel edges).
- **directed** (bool, optional): If True, creates a directed graph.
- **efile** (str, optional): Path to a file to load graph data from.
- **encoding** (str, optional): The encoding to use for the graph name and attributes.
- **attr** (dict, optional): A dictionary of attributes to set for the graph.

### Request Body (Implicit for attributes)
Attributes can be passed as keyword arguments.

### Response
- **self**: The initialized AGraph object.

### Example (Conceptual)
```python
import pygraphviz as gv

# Create a directed graph with custom attributes
G = gv.AGraph(name='my_graph', directed=True, charset='utf-8', label='My Graph')

# Add nodes and edges from a dictionary
data = {'A': {'B': {}, 'C': {}}, 'B': {'C': {}}}
G.add_nodes_from(data.keys())
for node, neighbors in data.items():
    for neighbor in neighbors:
        G.add_edge(node, neighbor)
```
```

--------------------------------

### Load Graph from String

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Shows how to load a graph from a string in DOT format. The `from_string` method overwrites existing graphs. Alternatively, specify the string during initialization.

```python
>>> import pygraphviz as pgv
>>> s = "digraph {1 -> 2}"
>>> A = pgv.AGraph()
>>> t = A.from_string(s)
>>> A = pgv.AGraph(string=s)  # specify s is a string
>>> A = pgv.AGraph(s)  # s assumed to be a string during initialization
```

--------------------------------

### Create and Modify a Graph with PyGraphviz

Source: https://pygraphviz.github.io/documentation/latest/index.html

Demonstrates initializing an AGraph object, adding nodes and edges, and printing the resulting graph structure.

```python
>>> import pygraphviz as pgv
>>> G = pgv.AGraph()
>>> G.add_node("a")
>>> G.add_edge("b", "c")
>>> print(G)
strict graph "" {
        a;
        b -- c;
}
```

--------------------------------

### Update documentation repository

Source: https://pygraphviz.github.io/documentation/latest/developer/release.html

Commands to copy and commit the new documentation version in the separate documentation repository.

```bash
# FIXME - use eol_banner.html
cp -a latest ../pygraphviz-${VERSION}
git reset --hard <commit from last release>
mv ../pygraphviz-${VERSION} .
rm -rf stable
cp -rf pygraphviz-${VERSION} stable
git add pygraphviz-${VERSION} stable
git commit -m "Add ${VERSION} docs"
git push  # force push---be careful!
```

--------------------------------

### Run Graphviz Program with Arguments

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Internal method to execute Graphviz programs with specified arguments. Handles process creation, input/output redirection, and error handling. Uses `subprocess.Popen` and threading for non-blocking I/O.

```python
runprog = rf'"{self._get_prog(prog)}"'
cmd = " ".join([runprog, args])
dotargs = shlex.split(cmd)
popen_kwargs = {}
if hasattr(subprocess, "CREATE_NO_WINDOW"):  # Only on Windows OS
    popen_kwargs.update(creationflags=subprocess.CREATE_NO_WINDOW)
p = subprocess.Popen(
    dotargs,
    shell=False,
    stdin=subprocess.PIPE,
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    close_fds=False,
    **popen_kwargs,
)
(child_stdin, child_stdout, child_stderr) = (p.stdin, p.stdout, p.stderr)
# Use threading to avoid blocking
data = []
errors = []
threads = [PipeReader(data, child_stdout), PipeReader(errors, child_stderr)]
for t in threads:
    t.start()

self.write(child_stdin)
child_stdin.close()

for t in threads:
    t.join()
p.wait()

if not data:
    raise OSError(b"",).join(errors).decode(self.encoding))

if len(errors) > 0:
    warnings.warn(b"",).join(errors).decode(self.encoding), RuntimeWarning)
return b"",).join(data)
```

--------------------------------

### Pass Additional Arguments to Graphviz

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Illustrates how to pass additional arguments to the Graphviz layout engine using the `args` parameter in the `draw` method. This allows fine-tuning of layout and node/edge attributes.

```python
>>> G.draw("test.pdf", prog="twopi", args="-Gepsilon=1")
>>> G.draw("test2.pdf", args="-Nshape=box -Edir=forward -Ecolor=red ")
```

--------------------------------

### Draw Graph with Layout

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Outputs the graph to a file in a specified format using a chosen Graphviz layout program. If path is None, the result is returned as bytes.

```python
>>> import pygraphviz as pgv
>>> G = pgv.AGraph()
>>> G.add_edges_from([(0, 1), (1, 2), (2, 0), (2, 3)])
>>> G.layout()
```

```python
# use current node positions, output pdf in ‘file.pdf’ >>> G.draw(“file.pdf”)
```

```python
# use dot to position, output png in ‘file’ >>> G.draw(“file”, format=”png”, prog=”dot”)
```

--------------------------------

### Locate Executable

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Searches for a program in the system PATH.

```python
    def _which(self, name):
        """Searches for name in exec path and returns full path"""
        import glob
        import platform

        if platform.system() == "Windows":
            name += ".exe"

        paths = os.environ["PATH"]
        for path in paths.split(os.pathsep):
            match = glob.glob(os.path.join(path, name))
            if match:
                return match[0]
        raise ValueError(f"No prog {name} in path.")
```

--------------------------------

### Set Graph Attributes

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Shows how to set graph-level attributes like 'landscape' and 'ranksep' during initialization or by updating the 'graph_attr' dictionary.

```python
>>> G = pgv.AGraph(landscape="true", ranksep="0.1")
```

```python
>>> G = pgv.AGraph()
>>> G.graph_attr.update(landscape="true", ranksep="0.1")
```

--------------------------------

### Initialize AGraph with a string

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Create an AGraph instance from a string containing Graphviz DOT language. The encoding can be specified within the string.

```python
>>> G = pgv.AGraph("file.dot")  # doctest: +SKIP
```

--------------------------------

### Initialize AGraph with a dictionary

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Create an AGraph instance from a dictionary representing nodes and edges. This is useful for programmatically building graphs.

```python
>>> import pygraphviz as pgv
>>> d = {"1": {"2": None}, "2": {"1": None, "3": None}, "3": {"2": None}}
>>> A = pgv.AGraph(d)
>>> s = A.to_string()
>>> B = pgv.AGraph(s)
>>> h = B.handle
>>> C = pgv.AGraph(h)
```

--------------------------------

### Manage Feature Branches

Source: https://pygraphviz.github.io/documentation/latest/developer/contribute.html

Commands to synchronize with the upstream repository and create a new feature branch.

```bash
git checkout main
git pull upstream main
```

```bash
git checkout -b bugfix-for-issue-1480
```

--------------------------------

### Push tags to GitHub

Source: https://pygraphviz.github.io/documentation/latest/developer/release.html

Push the newly created tags to the remote repository.

```bash
git push --tags origin main
```

--------------------------------

### Initialize AGraph from Various Data Types

Source: https://pygraphviz.github.io/documentation/latest/release/old_release_log.html

The `AGraph` constructor can accept various data types for initialization, including filenames, strings in dot format, dictionaries of dictionaries, or SWIG AGraph pointers.

```python
AGraph(data)
```

--------------------------------

### Create and Draw a Star Graph

Source: https://pygraphviz.github.io/documentation/latest/_downloads/4e83e39a7d255093d0acd5faad5cd483/plot_star.ipynb

Use PyGraphviz to create a star graph, customize node fill color, height, and width, and then print the DOT string, write to a DOT file, and draw to a PNG image using the 'circo' layout.

```python
#    Copyright (C) 2006 by
#    Aric Hagberg <hagberg@lanl.gov>
#    Dan Schult <dschult@colgate.edu>
#    Manos Renieris, http://www.cs.brown.edu/~er/
#    Distributed with BSD license.
#    All rights reserved, see LICENSE for details.

__author__ = """Aric Hagberg (hagberg@lanl.gov)"""

from pygraphviz import *

A = AGraph()

# set some default node attributes
A.node_attr["style"] = "filled"
A.node_attr["shape"] = "circle"
A.node_attr["fixedsize"] = "true"
A.node_attr["fontcolor"] = "#FFFFFF"

# make a star in shades of red
for i in range(1, 16):
    A.add_edge(0, i)
    n = A.get_node(i)
    n.attr["fillcolor"] = f"#{i * 16:2x}0000"
    n.attr["height"] = f"{i / 16.0 + 0.5}"
    n.attr["width"] = f"{i / 16.0 + 0.5}"

print(A.string())  # print to screen
A.write("star.dot")  # write to simple.dot
A.draw("star.png", prog="circo")  # draw to png using circo layout
```

--------------------------------

### Initialize AGraph with graph attributes

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Initialize an AGraph with Graphviz graph attributes directly. These attributes control the overall graph rendering.

```python
>>> G = pgv.AGraph(landscape="true", ranksep="0.1")
```

--------------------------------

### POST /layout

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Assigns positions to nodes in the graph using a specified layout program.

```APIDOC
## POST /layout

### Description
Assigns positions to nodes in the graph using libgvc.

### Method
POST

### Endpoint
/layout

### Parameters
#### Query Parameters
- **prog** (string) - Optional - The layout method to use (e.g., 'neato', 'dot', 'twopi', 'circo', 'fdp', 'nop').
- **args** (string) - Optional - Additional arguments for the layout program.
```

--------------------------------

### Run All PyGraphviz Tests

Source: https://pygraphviz.github.io/documentation/latest/developer/contribute.html

Execute all tests for the PyGraphviz package using pytest. Ensure PYTHONPATH is set to the project root.

```bash
$ PYTHONPATH=. pytest pygraphviz

```

--------------------------------

### Initialize AGraph

Source: https://pygraphviz.github.io/documentation/latest/tutorial.html

Various methods to instantiate an AGraph object, including empty graphs, specific graph types, and loading from files or data structures.

```python
>>> G = pgv.AGraph()
```

```python
>>> G = pgv.AGraph(strict=False, directed=True)
```

```python
>>> G = pgv.AGraph("Petersen.dot")
```

```python
>>> G = pgv.AGraph("graph {1 - 2}")
```

```python
>>> d = {"1": {"2": None}, "2": {"1": None, "3": None}, "3": {"2": None}}
>>> A = pgv.AGraph(d)
```

```python
>>> h = A.handle
>>> C = pgv.AGraph(h)
```

--------------------------------

### Layout and Draw Graph

Source: https://pygraphviz.github.io/documentation/latest/release/old_release_log.html

The `layout()` and `draw()` methods are used to position nodes and render the graph in various Graphviz output formats. These methods leverage Graphviz's layout algorithms.

```python
A.layout()
```

```python
A.draw()
```

--------------------------------

### Set Node and Edge Attributes

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Illustrates how to set default attributes for nodes and edges by updating 'node_attr' and 'edge_attr' dictionaries.

```python
>>> G.node_attr.update(color="red")
>>> G.edge_attr.update(len="2.0", color="blue")
```

--------------------------------

### Layout and Drawing

Source: https://pygraphviz.github.io/documentation/latest/tutorial.html

Methods for exporting graph data, applying layout algorithms, and rendering graphs to files.

```python
>>> s = G.string()
```

```python
>>> G.write("file.dot")
```

```python
>>> G.layout()  # default to neato
>>> G.layout(prog="dot")  # use dot
```

```python
>>> G.draw("file.png")  # write previously positioned graph to PNG file
>>> G.draw("file.ps", prog="circo")  # use circo to position, write PS file
```

--------------------------------

### Add Node with Attributes

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

Nodes can be created with attributes, or attributes can be updated after creation. Attribute values must be strings.

```python
>>> G.add_node(2, color="red")
```

--------------------------------

### Read and Write DOT Files

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Methods for loading and saving graph structures using file paths or handles.

```python
G.read("file.dot")
```

```python
G.write("file.dot")
```

--------------------------------

### POST /unflatten

Source: https://pygraphviz.github.io/documentation/latest/_modules/pygraphviz/agraph.html

Adjusts directed graphs to improve layout aspect ratio using the unflatten program.

```APIDOC
## POST /unflatten

### Description
Adjusts directed graphs to improve layout aspect ratio.

### Method
POST

### Endpoint
/unflatten

### Parameters
#### Query Parameters
- **args** (string) - Optional - Additional arguments to pass to the unflatten program.
```

--------------------------------

### Graph Utility Methods

Source: https://pygraphviz.github.io/documentation/latest/reference/agraph.html

General utility methods for graph state management.

```APIDOC
## clear()

### Description
Removes all nodes, edges, and attributes from the graph.

## copy()

### Description
Returns a deep copy of the graph.

## degree(nbunch=None, with_labels=False)

### Description
Returns the degree of nodes in the specified container.
```
Tokens:
Raw