Skip to main content
`Ctrl`+`K`

# Source code for networkx.readwrite.gml

    """
    Read graphs in GML format.

    "GML, the Graph Modelling Language, is our proposal for a portable
    file format for graphs. GML's key features are portability, simple
    syntax, extensibility and flexibility. A GML file consists of a
    hierarchical key-value lists. Graphs can be annotated with arbitrary
    data structures. The idea for a common file format was born at the
    GD'95; this proposal is the outcome of many discussions. GML is the
    standard file format in the Graphlet graph editor system. It has been
    overtaken and adapted by several other systems for drawing graphs."

    GML files are stored using a 7-bit ASCII encoding with any extended
    ASCII characters (iso8859-1) appearing as HTML character entities.
    You will need to give some thought into how the exported data should
    interact with different languages and even different Python versions.
    Re-importing from gml is also a concern.

    Without specifying a `stringizer`/`destringizer`, the code is capable of
    writing `int`/`float`/`str`/`dict`/`list` data as required by the GML
    specification.  For writing other data types, and for reading data other
    than `str` you need to explicitly supply a `stringizer`/`destringizer`.

    For additional documentation on the GML file format, please see the
    `GML website <https://web.archive.org/web/20190207140002/http://www.fim.uni-passau.de/index.php?id=17297&L=1>`_.

    Several example graphs in GML format may be found on Mark Newman's
    `Network data page <http://www-personal.umich.edu/~mejn/netdata/>`_.
    """

    import html.entities as htmlentitydefs
    import re
    import warnings
    from ast import literal_eval
    from collections import defaultdict
    from enum import Enum
    from io import StringIO
    from typing import Any, NamedTuple

    import networkx as nx
    from networkx.exception import NetworkXError
    from networkx.utils import open_file

    __all__ = ["read_gml", "parse_gml", "generate_gml", "write_gml"]

    def escape(text):
        """Use XML character references to escape characters.

        Use XML character references for unprintable or non-ASCII
        characters, double quotes and ampersands in a string
        """

        def fixup(m):
            ch = m.group(0)
            return "&#" + str(ord(ch)) + ";"

        text = re.sub('[^ -~]|[&"]', fixup, text)
        return text if isinstance(text, str) else str(text)

    def unescape(text):
        """Replace XML character references with the referenced characters"""

        def fixup(m):
            text = m.group(0)
            if text[1] == "#":
                # Character reference
                if text[2] == "x":
                    code = int(text[3:-1], 16)
                else:
                    code = int(text[2:-1])
            else:
                # Named entity
                try:
                    code = htmlentitydefs.name2codepoint[text[1:-1]]
                except KeyError:
                    return text  # leave unchanged
            try:
                return chr(code)
            except (ValueError, OverflowError):
                return text  # leave unchanged

        return re.sub("&(?:[0-9A-Za-z]+|#(?:[0-9]+|x[0-9A-Fa-f]+));", fixup, text)

    def literal_destringizer(rep):
        """Convert a Python literal to the value it represents.

        Parameters
        ----------
        rep : string
            A Python literal.

        Returns
        -------
        value : object
            The value of the Python literal.

        Raises
        ------
        ValueError
            If `rep` is not a Python literal.
        """
        if isinstance(rep, str):
            orig_rep = rep
            try:
                return literal_eval(rep)
            except SyntaxError as err:
                raise ValueError(f"{orig_rep!r} is not a valid Python literal") from err
        else:
            raise ValueError(f"{rep!r} is not a string")

    @open_file(0, mode="rb")
    @nx._dispatchable(graphs=None, returns_graph=True)
    def read_gml(path, label="label", destringizer=None):
        """Read graph in GML format from `path`.

        Parameters
        ----------
        path : filename or filehandle
            The filename or filehandle to read from.

        label : string, optional
            If not None, the parsed nodes will be renamed according to node
            attributes indicated by `label`. Default value: 'label'.

        destringizer : callable, optional
            A `destringizer` that recovers values stored as strings in GML. If it
            cannot convert a string to a value, a `ValueError` is raised. Default
            value : None.

        Returns
        -------
        G : NetworkX graph
            The parsed graph.

        Raises
        ------
        NetworkXError
            If the input cannot be parsed.

        See Also
        --------
        write_gml, parse_gml
        literal_destringizer

        Notes
        -----
        GML files are stored using a 7-bit ASCII encoding with any extended
        ASCII characters (iso8859-1) appearing as HTML character entities.
        Without specifying a `stringizer`/`destringizer`, the code is capable of
        writing `int`/`float`/`str`/`dict`/`list` data as required by the GML
        specification.  For writing other data types, and for reading data other
        than `str` you need to explicitly supply a `stringizer`/`destringizer`.

        For additional documentation on the GML file format, please see the
        `GML url <https://web.archive.org/web/20190207140002/http://www.fim.uni-passau.de/index.php?id=17297&L=1>`_.

        See the module docstring :mod:`networkx.readwrite.gml` for more details.

        Examples
        --------
        >>> G = nx.path_graph(4)
        >>> nx.write_gml(G, "test.gml")

        GML values are interpreted as strings by default:

        >>> H = nx.read_gml("test.gml")
        >>> H.nodes
        NodeView(('0', '1', '2', '3'))

        When a `destringizer` is provided, GML values are converted to the provided type.
        For example, integer nodes can be recovered as shown below:

        >>> J = nx.read_gml("test.gml", destringizer=int)
        >>> J.nodes
        NodeView((0, 1, 2, 3))

        """

        def filter_lines(lines):
            for line in lines:
                try:
                    line = line.decode("ascii")
                except UnicodeDecodeError as err:
                    raise NetworkXError("input is not ASCII-encoded") from err
                if not isinstance(line, str):
                    lines = str(lines)
                if line and line[-1] == "\n":
                    line = line[:-1]
                yield line

        G = parse_gml_lines(filter_lines(path), label, destringizer)
        return G

    @nx._dispatchable(graphs=None, returns_graph=True)
    def parse_gml(lines, label="label", destringizer=None):
        """Parse GML graph from a string or iterable.

        Parameters
        ----------
        lines : string or iterable of strings
           Data in GML format.

        label : string, optional
            If not None, the parsed nodes will be renamed according to node
            attributes indicated by `label`. Default value: 'label'.

        destringizer : callable, optional
            A `destringizer` that recovers values stored as strings in GML. If it
            cannot convert a string to a value, a `ValueError` is raised. Default
            value : None.

        Returns
        -------
        G : NetworkX graph
            The parsed graph.

        Raises
        ------
        NetworkXError
            If the input cannot be parsed.

        See Also
        --------
        write_gml, read_gml

        Notes
        -----
        This stores nested GML attributes as dictionaries in the NetworkX graph,
        node, and edge attribute structures.

        GML files are stored using a 7-bit ASCII encoding with any extended
        ASCII characters (iso8859-1) appearing as HTML character entities.
        Without specifying a `stringizer`/`destringizer`, the code is capable of
        writing `int`/`float`/`str`/`dict`/`list` data as required by the GML
        specification.  For writing other data types, and for reading data other
        than `str` you need to explicitly supply a `stringizer`/`destringizer`.

        For additional documentation on the GML file format, please see the
        `GML url <https://web.archive.org/web/20190207140002/http://www.fim.uni-passau.de/index.php?id=17297&L=1>`_.

        See the module docstring :mod:`networkx.readwrite.gml` for more details.
        """

        def decode_line(line):
            if isinstance(line, bytes):
                try:
                    line.decode("ascii")
                except UnicodeDecodeError as err:
                    raise NetworkXError("input is not ASCII-encoded") from err
            if not isinstance(line, str):
                line = str(line)
            return line

        def filter_lines(lines):
            if isinstance(lines, str):
                lines = decode_line(lines)
                lines = lines.splitlines()
                yield from lines
            else:
                for line in lines:
                    line = decode_line(line)
                    if line and line[-1] == "\n":
                        line = line[:-1]
                    if line.find("\n") != -1:
                        raise NetworkXError("input line contains newline")
                    yield line

        G = parse_gml_lines(filter_lines(lines), label, destringizer)
        return G

    class Pattern(Enum):
        """encodes the index of each token-matching pattern in `tokenize`."""

        KEYS = 0
        REALS = 1
        INTS = 2
        STRINGS = 3
        DICT_START = 4
        DICT_END = 5
        COMMENT_WHITESPACE = 6

    class Token(NamedTuple):
        category: Pattern
        value: Any
        line: int
        position: int

    LIST_START_VALUE = "_networkx_list_start"

    def parse_gml_lines(lines, label, destringizer):
        """Parse GML `lines` into a graph."""

        def tokenize():
            patterns = [
                r"[A-Za-z][0-9A-Za-z_]*\b",  # keys
                # reals
                r"[+-]?(?:[0-9]*\.[0-9]+|[0-9]+\.[0-9]*|INF)(?:[Ee][+-]?[0-9]+)?",
                r"[+-]?[0-9]+",  # ints
                r'".*?"',  # strings
                r"\[",  # dict start
                r"\]",  # dict end
                r"#.*$|\s+",  # comments and whitespaces
            ]
            tokens = re.compile("|".join(f"({pattern})" for pattern in patterns))
            lineno = 0
            multilines = []  # entries spread across multiple lines
            for line in lines:
                pos = 0

                # deal with entries spread across multiple lines
                #
                # should we actually have to deal with escaped "s then do it here
                if multilines:
                    multilines.append(line.strip())
                    if line[-1] == '"':  # closing multiline entry
                        # multiline entries will be joined by space. cannot
                        # reintroduce newlines as this will break the tokenizer
                        line = " ".join(multilines)
                        multilines = []
                    else:  # continued multiline entry
                        lineno += 1
                        continue
                else:
                    if line.count('"') == 1:  # opening multiline entry
                        if line.strip()[0] != '"' and line.strip()[-1] != '"':
                            # since we expect something like key "value", the " should not be found at ends
                            # otherwise tokenizer will pick up the formatting mistake.
                            multilines = [line.rstrip()]
                            lineno += 1
                            continue

                length = len(line)

                while pos < length:
                    match = tokens.match(line, pos)
                    if match is None:
                        m = f"cannot tokenize {line[pos:]} at ({lineno + 1}, {pos + 1})"
                        raise NetworkXError(m)
                    for i in range(len(patterns)):
                        group = match.group(i + 1)
                        if group is not None:
                            if i == 0:  # keys
                                value = group.rstrip()
                            elif i == 1:  # reals
                                value = float(group)
                            elif i == 2:  # ints
                                value = int(group)
                            else:
                                value = group
                            if i != 6:  # comments and whitespaces
                                yield Token(Pattern(i), value, lineno + 1, pos + 1)
                            pos += len(group)
                            break
                lineno += 1
            yield Token(None, None, lineno + 1, 1)  # EOF

        def unexpected(curr_token, expected):
            category, value, lineno, pos = curr_token
            value = repr(value) if value is not None else "EOF"
            raise NetworkXError(f"expected {expected}, found {value} at ({lineno}, {pos})")

        def consume(curr_token, category, expected):
            if curr_token.category == category:
                return next(tokens)
            unexpected(curr_token, expected)

        def parse_kv(curr_token):
            dct = defaultdict(list)
            while curr_token.category == Pattern.KEYS:
                key = curr_token.value
                curr_token = next(tokens)
                category = curr_token.category
                if category == Pattern.REALS or category == Pattern.INTS:
                    value = curr_token.value
                    curr_token = next(tokens)
                elif category == Pattern.STRINGS:
                    value = unescape(curr_token.value[1:-1])
                    if destringizer:
                        try:
                            value = destringizer(value)
                        except ValueError:
                            pass
                    # Special handling for empty lists and tuples
                    if value == "()":
                        value = ()
                    if value == "[]":
                        value = []
                    curr_token = next(tokens)
                elif category == Pattern.DICT_START:
                    curr_token, value = parse_dict(curr_token)
                else:
                    # Allow for string convertible id and label values
                    if key in ("id", "label", "source", "target"):
                        try:
                            # String convert the token value
                            value = unescape(str(curr_token.value))
                            if destringizer:
                                try:
                                    value = destringizer(value)
                                except ValueError:
                                    pass
                            curr_token = next(tokens)
                        except Exception:
                            msg = (
                                "an int, float, string, '[' or string"
                                + " convertible ASCII value for node id or label"
                            )
                            unexpected(curr_token, msg)
                    # Special handling for nan and infinity.  Since the gml language
                    # defines unquoted strings as keys, the numeric and string branches
                    # are skipped and we end up in this special branch, so we need to
                    # convert the current token value to a float for NAN and plain INF.
                    # +/-INF are handled in the pattern for 'reals' in tokenize().  This
                    # allows labels and values to be nan or infinity, but not keys.
                    elif curr_token.value in {"NAN", "INF"}:
                        value = float(curr_token.value)
                        curr_token = next(tokens)
                    else:  # Otherwise error out
                        unexpected(curr_token, "an int, float, string or '['")
                dct[key].append(value)

            def clean_dict_value(value):
                if not isinstance(value, list):
                    return value
                if len(value) == 1:
                    return value[0]
                if value[0] == LIST_START_VALUE:
                    return value[1:]
                return value

            dct = {key: clean_dict_value(value) for key, value in dct.items()}
            return curr_token, dct

        def parse_dict(curr_token):
            # dict start
            curr_token = consume(curr_token, Pattern.DICT_START, "'['")
            # dict contents
            curr_token, dct = parse_kv(curr_token)
            # dict end
            curr_token = consume(curr_token, Pattern.DICT_END, "']'")
            return curr_token, dct

        def parse_graph():
            curr_token, dct = parse_kv(next(tokens))
            if curr_token.category is not None:  # EOF
                unexpected(curr_token, "EOF")
            if "graph" not in dct:
                raise NetworkXError("input contains no graph")
            graph = dct["graph"]
            if isinstance(graph, list):
                raise NetworkXError("input contains more than one graph")
            return graph

        tokens = tokenize()
        graph = parse_graph()

        directed = graph.pop("directed", False)
        multigraph = graph.pop("multigraph", False)
        if not multigraph:
            G = nx.DiGraph() if directed else nx.Graph()
        else:
            G = nx.MultiDiGraph() if directed else nx.MultiGraph()
        graph_attr = {k: v for k, v in graph.items() if k not in ("node", "edge")}
        G.graph.update(graph_attr)

        def pop_attr(dct, category, attr, i):
            try:
                return dct.pop(attr)
            except KeyError as err:
                raise NetworkXError(f"{category} #{i} has no {attr!r} attribute") from err

        nodes = graph.get("node", [])
        mapping = {}
        node_labels = set()
        for i, node in enumerate(nodes if isinstance(nodes, list) else [nodes]):
            id = pop_attr(node, "node", "id", i)
            if id in G:
                raise NetworkXError(f"node id {id!r} is duplicated")
            if label is not None and label != "id":
                node_label = pop_attr(node, "node", label, i)
                if node_label in node_labels:
                    raise NetworkXError(f"node label {node_label!r} is duplicated")
                node_labels.add(node_label)
                mapping[id] = node_label
            G.add_node(id, **node)

        edges = graph.get("edge", [])
        for i, edge in enumerate(edges if isinstance(edges, list) else [edges]):
            source = pop_attr(edge, "edge", "source", i)
            target = pop_attr(edge, "edge", "target", i)
            if source not in G:
                raise NetworkXError(f"edge #{i} has undefined source {source!r}")
            if target not in G:
                raise NetworkXError(f"edge #{i} has undefined target {target!r}")
            if not multigraph:
                if not G.has_edge(source, target):
                    G.add_edge(source, target, **edge)
                else:
                    arrow = "->" if directed else "--"
                    msg = f"edge #{i} ({source!r}{arrow}{target!r}) is duplicated"
                    raise nx.NetworkXError(msg)
            else:
                key = edge.pop("key", None)
                if key is not None and G.has_edge(source, target, key):
                    arrow = "->" if directed else "--"
                    msg = f"edge #{i} ({source!r}{arrow}{target!r}, {key!r})"
                    msg2 = 'Hint: If multigraph add "multigraph 1" to file header.'
                    raise nx.NetworkXError(msg + " is duplicated\n" + msg2)
                G.add_edge(source, target, key, **edge)

        if label is not None and label != "id":
            G = nx.relabel_nodes(G, mapping)
        return G

    def literal_stringizer(value):
        """Convert a `value` to a Python literal in GML representation.

        Parameters
        ----------
        value : object
            The `value` to be converted to GML representation.

        Returns
        -------
        rep : string
            A double-quoted Python literal representing value. Unprintable
            characters are replaced by XML character references.

        Raises
        ------
        ValueError
            If `value` cannot be converted to GML.

        Notes
        -----
        The original value can be recovered using the
        :func:`networkx.readwrite.gml.literal_destringizer` function.
        """

        def stringize(value):
            if isinstance(value, int | bool) or value is None:
                if value is True:  # GML uses 1/0 for boolean values.
                    buf.write(str(1))
                elif value is False:
                    buf.write(str(0))
                else:
                    buf.write(str(value))
            elif isinstance(value, str):
                text = repr(value)
                if text[0] != "u":
                    try:
                        value.encode("latin1")
                    except UnicodeEncodeError:
                        text = "u" + text
                buf.write(text)
            elif isinstance(value, float | complex | str | bytes):
                buf.write(repr(value))
            elif isinstance(value, list):
                buf.write("[")
                first = True
                for item in value:
                    if not first:
                        buf.write(",")
                    else:
                        first = False
                    stringize(item)
                buf.write("]")
            elif isinstance(value, tuple):
                if len(value) > 1:
                    buf.write("(")
                    first = True
                    for item in value:
                        if not first:
                            buf.write(",")
                        else:
                            first = False
                        stringize(item)
                    buf.write(")")
                elif value:
                    buf.write("(")
                    stringize(value[0])
                    buf.write(",)")
                else:
                    buf.write("()")
            elif isinstance(value, dict):
                buf.write("{")
                first = True
                for key, value in value.items():
                    if not first:
                        buf.write(",")
                    else:
                        first = False
                    stringize(key)
                    buf.write(":")
                    stringize(value)
                buf.write("}")
            elif isinstance(value, set):
                buf.write("{")
                first = True
                for item in value:
                    if not first:
                        buf.write(",")
                    else:
                        first = False
                    stringize(item)
                buf.write("}")
            else:
                msg = f"{value!r} cannot be converted into a Python literal"
                raise ValueError(msg)

        buf = StringIO()
        stringize(value)
        return buf.getvalue()

    def generate_gml(G, stringizer=None):
        r"""Generate a single entry of the graph `G` in GML format.

        Parameters
        ----------
        G : NetworkX graph
            The graph to be converted to GML.

        stringizer : callable, optional
            A `stringizer` which converts non-int/non-float/non-dict values into
            strings. If it cannot convert a value into a string, it should raise a
            `ValueError` to indicate that. Default value: None.

        Returns
        -------
        lines: generator of strings
            Lines of GML data. Newlines are not appended.

        Raises
        ------
        NetworkXError
            If `stringizer` cannot convert a value into a string, or the value to
            convert is not a string while `stringizer` is None.

        See Also
        --------
        literal_stringizer

        Notes
        -----
        Graph attributes named 'directed', 'multigraph', 'node' or
        'edge', node attributes named 'id' or 'label', edge attributes
        named 'source' or 'target' (or 'key' if `G` is a multigraph)
        are ignored because these attribute names are used to encode the graph
        structure.

        GML files are stored using a 7-bit ASCII encoding with any extended
        ASCII characters (iso8859-1) appearing as HTML character entities.
        Without specifying a `stringizer`/`destringizer`, the code is capable of
        writing `int`/`float`/`str`/`dict`/`list` data as required by the GML
        specification.  For writing other data types, and for reading data other
        than `str` you need to explicitly supply a `stringizer`/`destringizer`.

        For additional documentation on the GML file format, please see the
        `GML url <https://web.archive.org/web/20190207140002/http://www.fim.uni-passau.de/index.php?id=17297&L=1>`_.

        See the module docstring :mod:`networkx.readwrite.gml` for more details.

        Examples
        --------
        >>> G = nx.Graph()
        >>> G.add_node("1")
        >>> print("\n".join(nx.generate_gml(G)))
        graph [
          node [
            id 0
            label "1"
          ]
        ]
        >>> G = nx.MultiGraph([("a", "b"), ("a", "b")])
        >>> print("\n".join(nx.generate_gml(G)))
        graph [
          multigraph 1
          node [
            id 0
            label "a"
          ]
          node [
            id 1
            label "b"
          ]
          edge [
            source 0
            target 1
            key 0
          ]
          edge [
            source 0
            target 1
            key 1
          ]
        ]
        """
        valid_keys = re.compile("^[A-Za-z][0-9A-Za-z_]*$")

        def stringize(key, value, ignored_keys, indent, in_list=False):
            if not isinstance(key, str):
                raise NetworkXError(f"{key!r} is not a string")
            if not valid_keys.match(key):
                raise NetworkXError(f"{key!r} is not a valid key")
            if not isinstance(key, str):
                key = str(key)
            if key not in ignored_keys:
                if isinstance(value, int | bool):
                    if key == "label":
                        yield indent + key + ' "' + str(value) + '"'
                    elif value is True:
                        # python bool is an instance of int
                        yield indent + key + " 1"
                    elif value is False:
                        yield indent + key + " 0"
                    # GML only supports signed 32-bit integers
                    elif value < -(2**31) or value >= 2**31:
                        yield indent + key + ' "' + str(value) + '"'
                    else:
                        yield indent + key + " " + str(value)
                elif isinstance(value, float):
                    text = repr(value).upper()
                    # GML matches INF to keys, so prepend + to INF. Use repr(float(*))
                    # instead of string literal to future proof against changes to repr.
                    if text == repr(float("inf")).upper():
                        text = "+" + text
                    else:
                        # GML requires that a real literal contain a decimal point, but
                        # repr may not output a decimal point when the mantissa is
                        # integral and hence needs fixing.
                        epos = text.rfind("E")
                        if epos != -1 and text.find(".", 0, epos) == -1:
                            text = text[:epos] + "." + text[epos:]
                    if key == "label":
                        yield indent + key + ' "' + text + '"'
                    else:
                        yield indent + key + " " + text
                elif isinstance(value, dict):
                    yield indent + key + " ["
                    next_indent = indent + "  "
                    for key, value in value.items():
                        yield from stringize(key, value, (), next_indent)
                    yield indent + "]"
                elif isinstance(value, tuple) and key == "label":
                    yield indent + key + f" \"({','.join(repr(v) for v in value)})\""
                elif isinstance(value, list | tuple) and key != "label" and not in_list:
                    if len(value) == 0:
                        yield indent + key + " " + f'"{value!r}"'
                    if len(value) == 1:
                        yield indent + key + " " + f'"{LIST_START_VALUE}"'
                    for val in value:
                        yield from stringize(key, val, (), indent, True)
                else:
                    if stringizer:
                        try:
                            value = stringizer(value)
                        except ValueError as err:
                            raise NetworkXError(
                                f"{value!r} cannot be converted into a string"
                            ) from err
                    if not isinstance(value, str):
                        raise NetworkXError(f"{value!r} is not a string")
                    yield indent + key + ' "' + escape(value) + '"'

        multigraph = G.is_multigraph()
        yield "graph ["

        # Output graph attributes
        if G.is_directed():
            yield "  directed 1"
        if multigraph:
            yield "  multigraph 1"
        ignored_keys = {"directed", "multigraph", "node", "edge"}
        for attr, value in G.graph.items():
            yield from stringize(attr, value, ignored_keys, "  ")

        # Output node data
        node_id = dict(zip(G, range(len(G))))
        ignored_keys = {"id", "label"}
        for node, attrs in G.nodes.items():
            yield "  node ["
            yield "    id " + str(node_id[node])
            yield from stringize("label", node, (), "    ")
            for attr, value in attrs.items():
                yield from stringize(attr, value, ignored_keys, "    ")
            yield "  ]"

        # Output edge data
        ignored_keys = {"source", "target"}
        kwargs = {"data": True}
        if multigraph:
            ignored_keys.add("key")
            kwargs["keys"] = True
        for e in G.edges(**kwargs):
            yield "  edge ["
            yield "    source " + str(node_id[e[0]])
            yield "    target " + str(node_id[e[1]])
            if multigraph:
                yield from stringize("key", e[2], (), "    ")
            for attr, value in e[-1].items():
                yield from stringize(attr, value, ignored_keys, "    ")
            yield "  ]"
        yield "]"

    @open_file(1, mode="wb")
    def write_gml(G, path, stringizer=None):
        """Write a graph `G` in GML format to the file or file handle `path`.

        Parameters
        ----------
        G : NetworkX graph
            The graph to be converted to GML.

        path : filename or filehandle
            The filename or filehandle to write. Files whose names end with .gz or
            .bz2 will be compressed.

        stringizer : callable, optional
            A `stringizer` which converts non-int/non-float/non-dict values into
            strings. If it cannot convert a value into a string, it should raise a
            `ValueError` to indicate that. Default value: None.

        Raises
        ------
        NetworkXError
            If `stringizer` cannot convert a value into a string, or the value to
            convert is not a string while `stringizer` is None.

        See Also
        --------
        read_gml, generate_gml
        literal_stringizer

        Notes
        -----
        Graph attributes named 'directed', 'multigraph', 'node' or
        'edge', node attributes named 'id' or 'label', edge attributes
        named 'source' or 'target' (or 'key' if `G` is a multigraph)
        are ignored because these attribute names are used to encode the graph
        structure.

        GML files are stored using a 7-bit ASCII encoding with any extended
        ASCII characters (iso8859-1) appearing as HTML character entities.
        Without specifying a `stringizer`/`destringizer`, the code is capable of
        writing `int`/`float`/`str`/`dict`/`list` data as required by the GML
        specification.  For writing other data types, and for reading data other
        than `str` you need to explicitly supply a `stringizer`/`destringizer`.

        Note that while we allow non-standard GML to be read from a file, we make
        sure to write GML format. In particular, underscores are not allowed in
        attribute names.
        For additional documentation on the GML file format, please see the
        `GML url <https://web.archive.org/web/20190207140002/http://www.fim.uni-passau.de/index.php?id=17297&L=1>`_.

        See the module docstring :mod:`networkx.readwrite.gml` for more details.

        Examples
        --------
        >>> G = nx.path_graph(4)
        >>> nx.write_gml(G, "test.gml")

        Filenames ending in .gz or .bz2 will be compressed.

        >>> nx.write_gml(G, "test.gml.gz")
        """
        for line in generate_gml(G, stringizer):
            path.write((line + "\n").encode("ascii"))