plot

Signature/Parameters

def plot(self, graph_style = None, nodes_label = None, nodes_position = None, estimates = None, node_subset = None, node_shape = None, node_size = None, node_color = None, node_border_color = None, node_border_style = None, node_border_width = None, node_latent_show = True, show_labels = True, use_labels = True, node_label_color = 'black', node_label_fontsize = None, node_label_fontweight = 'normal', node_label_adj_x = 0, node_label_adj_y = 0, node_label_box = None, node_label_box_style = 'square', node_label_box_margin = 0.5, edge_subset = None, edge_color = None, edge_style = None, edge_arc = None, edge_linewidth = None, edge_head_size = None, edge_head_style = None, edge_margin_tail = None, edge_margin_head = None, edge_label = None, edge_label_color_background = 'white', edge_label_color_border = 'white', edge_label_size = None, edge_label_color = None, edge_label_alpha = None, edge_label_rotate = None, edge_label_position = None, edge_label_estimates_sig_level = 0.05, edge_label_estimates_colors = {'negative': 'red', 'positive': 'blue'}, edge_label_estimates_face = None, edge_label_estimates_show_sig = True, edge_label_estimates_show_sig_alpha = {'Yes': 1, 'No': 0.2}, edge_label_estimates_show_ci = False, edge_label_estimates_show_ci_round = 4, edge_label_pvalue = None, edge_label_font_family = None, legend_show = True, legend_title = 'Nodes', legend_title_align = 'left', legend_title_weight = 'bold', legend_title_size = 12, legend_omit_cases = ['Observed'], legend_keys = None, legend_loc = 'best', legend_fontsize = 10, legend_frame = False, legend_kws = {}, title = None, title_loc = 'left', title_kws = {}, figsize = [6, 4], usetex = True, latex_packages = None, ax = None, show_plot = None, *args, **kws)

Render the DAG using matplotlib with extensive styling controls.

Parameters:

Name	Type	Description	Default
graph_style	(dict, str, None)	If str, it must be a name of a predefined built-in style (see causalinf.gcm.styles()). When None, falls back to the global plotting option. If dict, it must match the names of the keys of the built-in styles (see causalinf.gcm.styles(which=’default’)).	None
nodes_label	dict[str, str] or None	Mapping from node names to display labels.	None
nodes_position	dict[str, tuple[float, float]] or None	Coordinates to override automatic layout positions.	None
estimates	estimate or None	Output of causalinf.scm.estimate used to annotate edges with estimates and p-values.	None
node_subset	dict[str, list[str]] or None	Restrict plotting to specific node groups (e.g., observed, latent). Defaults to all nodes.	None
node_latent_show	bool	If False, omit latent nodes while preserving their effects via arcs. Defaults to True.	True
show_labels	bool	Display node labels when True (default).	True
use_labels	bool	When True (default), prefer custom labels over node names.	True
node_	dict or scalar or None	Control the visual attributes of nodes. Can be applied per node, per group based on node role, or to all nodes. Which case happends depends on the input: str, float, int -> apply to all nodes None -> use defaults based on GCM styles by type (see causalinf.gcm.styles()) dict -> apply to nodes or types based on the keys, which can be: Node Role: ‘Exposure’, “Outcome”, “Latent”, “Observed”, or any user-defined node role Node name Accepted values for each parameter: _shape: str _size: int, float _color: str _border_color: str _border_style: str (‘-‘, ‘solid’, ‘–‘, ‘dashed’, “:”, ‘dotted’) _border_width: int, float _label_color: str _label_fontsize: int, float _label_fontweight: str (normal, bold, italic) _label_adj_x: int, float _label_adj_y: int, float _label_box_style: str (“round”’) _label_box_margin: int, float	required
node_latent_show		If True, show latent nodes	True
node_label_box		If True, draw box around the label when using ‘rectangle’ node style.	None
edge_		Control the visual attributes of edges. Can be applied per edge, per edge type, or to all edges. Which case happends depends on the input: scalar -> apply to all edges None -> use defaults by edge type dict -> keys can be: edge type (case-insensitive): ‘directed’ -> apply to all directed edges ‘bidirected’ -> apply to all bidirected edges ‘undirected’ -> apply to all undirected edges actual edges. Example: (‘D’, ‘Y’) apply to the “D -> Y” directed edge ((‘D’, ‘Y’), (‘Y’, ‘D’)) apply to the “D <-> Y” bidirected edge frozenset({‘D’, ‘Y’}) apply to the “D – Y” undirected edge Accepted values for each parameter: _color: str _style: str (‘-‘, ‘solid’, ‘–‘, ‘dashed’, “:”, ‘dotted’) _arc: float _linewidth: float _head_size: float _head_style: str (‘->’, ‘-|>’) _margin_tail: float _margin_head: float _label: str _label_color_background: str _label_color_border: str _label_size: float _label_color: str _label_alpha: float _label_rotate: bool _label_position: float	required
edge_subset	dict[str, list] or None	Limit plotting to selected edges by type.	None
edge_label_estimates_sig_level	float	Significance level used when estimates include confidence bounds.	0.05
edge_label_estimates_colors	dict or None	Colors for negative and positive estimate labels. Use None to keep the default edge label color. Defaults to {"negative": "red", "positive": "blue"}.	{'negative': 'red', 'positive': 'blue'}
edge_label_estimates_face	dict or None	Font weight for negative and positive estimate labels, e.g. {"negative": "normal", "positive": "bold"}. Use None to keep the normal label weight.	None
edge_label_estimates_show_sig	bool	Append significance stars from the estimates summary when True. Defaults to True.	True
edge_label_estimates_show_sig_alpha	dict or None	Alpha values keyed by "Yes" and "No", where "Yes" means the estimate p-value is at or below edge_label_estimates_sig_level. Use None to keep the default edge label alpha. Defaults to {"Yes": .5, "No": 1}.	{'Yes': 1, 'No': 0.2}
edge_label_estimates_show_ci	bool	Add confidence intervals below the estimate label when True. Defaults to False.	False
edge_label_estimates_show_ci_round	int	Number of decimal places used for confidence interval bounds. Defaults to 4.	4
edge_label_pvalue	dict or None	P-value annotations keyed by edge.	None
edge_label_font_family	str or None	Font family for edge labels.	None
legend_show	bool	Display the legend when True (default).	True
legend_title	str	Legend title. Defaults to 'Nodes'.	'Nodes'
legend_title_align	(left, center, right)	Horizontal alignment for the legend title.	'left'
legend_title_weight	str	Font weight for the legend title.	'bold'
legend_title_size	int	Legend title font size.	12
legend_omit_cases	list[str]	Node role labels to omit from the legend.	['Observed']
legend_keys	dict or None	Custom legend entries keyed by role.	None
legend_loc	str	Legend placement for matplotlib.axes.Axes.legend.	'best'
legend_fontsize	int	Legend text size.	10
legend_frame	bool	Draw a frame around the legend when True.	False
legend_kws	dict	Additional keyword arguments forwarded to legend.	{}
title	str or None	Plot title.	None
title_loc	(left, center, right)	Title alignment. Defaults to 'left'.	'left'
title_kws	dict	Additional title styling options.	{}
figsize	Sequence[float]	Width and height (in inches) for the created figure. Defaults to [6, 4].	[6, 4]
usetex	bool	Enable LaTeX rendering for text. Defaults to True.	True
ax	Axes or None	Existing axis to draw on. A new figure and axis are created when None.	None
show_plot	bool or None	Override global option controlling whether plt.show() is called.	None
*args		Additional positional arguments forwarded to the internal plotting helpers.	()
**kws		Extra keyword arguments forwarded to the internal plotting helpers.	{}

Returns:

Type	Description
Axes	plot object and axis on which the graph is drawn.

Examples:

>>> G = DAG(graph="X -> Y")
>>> plt, ax = G.plot(figsize=(4, 3), show_plot=False)
True

>>> dag  = '''
>>> D -> M1
>>> M1 -- M2
>>> M2 -> Y
>>> M3 -> Y
>>> D <-> Y
>>> D  -> Y
>>> Z -> {D, Y}
>>> '''
>>> pos = {'D': (0,0),
>>>        'Y': (1,0),
>>>        'Z': (.5, -1),
>>>        'M1': (.25, 1),
>>>        'M2': (.75, 1),
>>>        'M3': (1.75, 1),
>>>        }
>>> pos2 = {'D': (.5,0),
>>>        'Y': (1,0),
>>>        'Z': (.5, -1),
>>>        'M1': (.25, 1),
>>>        'M2': (.75, 1),
>>>        'M3': (1.75, 1),
>>>        }
>>> roles = {'Exposure': "D",
>>>          'Outcome' : "Y",
>>>          "Latent"  : 'Z',
>>>          "M2 role" : "M2"
>>>          }
>>> labels = {"D": "$\widetilde{D}$",
>>>           "M1":'$M_1$',
>>>           'Y': "Outcome"}
>>> labels2 = {"D": "$\widetilde{D}_i$"}
>>> edge_label = {('D', 'M1') : 1,
>>>               ('M2', 'Y') : -1,
>>>               ('M3', 'Y') : 'a',
>>>               ('D', 'Y') : 'bsd;fkajsd;',
>>>               ('Z', 'D') : '$\beta$',
>>>               ('Z', 'Y'): 'asccc',
>>>               (('D', 'Y'), ('Y', 'D')): 'abc',
>>>                # ('M2', 'M1') : 1234, # no label for undireted edges
>>>               }
>>> 
>>> G = gcm.DAG(dag,  nodes_role=roles, nodes_position=pos, nodes_label=labels)  # 
>>> G.plot()
>>> 
>>> G.plot(node_color='red')
>>> G.plot(node_color={'D':'red'})
>>> G.plot(node_border_color={'D':'red'})
>>> G.plot(node_border_color={'Z':'red'})
>>> G.plot(node_border_color={'Z':'red'}, node_border_style={'D':':'})
>>> G.plot(node_border_color={'Z':'red'}, node_border_style={'D':':', 'Z':'solid'})

Source code in causalinf/gcm.py

def plot(self,
         # nodes
         graph_style = None,
         nodes_label=None,
         nodes_position=None,
         estimates=None,
         # node
         node_subset=None,
         node_shape=None,
         node_size = None,
         node_color = None,
         node_border_color=None,
         node_border_style=None,
         node_border_width=None,
         node_latent_show=True,
         # node label
         show_labels = True,
         use_labels = True,
         node_label_color='black',
         node_label_fontsize=None,
         node_label_fontweight='normal',
         node_label_adj_x=0,
         node_label_adj_y=0,
         node_label_box=None,
         node_label_box_style="square",
         node_label_box_margin=.5,
         # edges
         edge_subset=None,
         edge_color=None,
         edge_style=None,
         edge_arc = None,
         edge_linewidth = None,
         edge_head_size = None,
         edge_head_style = None,
         edge_margin_tail=None,
         edge_margin_head=None,
         # edges labels
         edge_label=None,
         edge_label_color_background='white',
         edge_label_color_border='white',
         edge_label_size=None,
         edge_label_color=None,
         edge_label_alpha=None,
         edge_label_rotate=None,
         edge_label_position=None,
         edge_label_estimates_sig_level=0.05,
         edge_label_estimates_colors={"negative":"red", "positive":"blue"},
         edge_label_estimates_face=None,
         edge_label_estimates_show_sig=True,
         edge_label_estimates_show_sig_alpha={"Yes": 1, "No": .2},
         edge_label_estimates_show_ci=False,
         edge_label_estimates_show_ci_round=4,
         edge_label_pvalue=None,
         edge_label_font_family = None,
         # legend
         legend_show=True,
         legend_title='Nodes',
         legend_title_align='left',
         legend_title_weight='bold',
         legend_title_size=12,
         legend_omit_cases=['Observed'],
         legend_keys=None,
         legend_loc='best',
         legend_fontsize=10,
         legend_frame=False,
         legend_kws={},
         #
         title = None,
         title_loc = 'left',
         title_kws = {},
         # 
         figsize = [6, 4],
         usetex = True,
         latex_packages = None,
         ax=None,
         show_plot=None,
         *args,
         **kws
         ):
    """
    Render the DAG using matplotlib with extensive styling controls.

    Parameters
    ----------
    graph_style : dict, str, None, optional
        If str, it must be a name of a predefined built-in style
        (see causalinf.gcm.styles()). When ``None``, falls
        back to the global plotting option. If dict, it must
        match the names of the keys of the built-in styles
        (see causalinf.gcm.styles(which='default')).
    nodes_label : dict[str, str] or None, optional
        Mapping from node names to display labels.
    nodes_position : dict[str, tuple[float, float]] or None, optional
        Coordinates to override automatic layout positions.
    estimates : estimate or None, optional
        Output of ``causalinf.scm.estimate`` used to annotate edges with
        estimates and p-values.
    node_subset : dict[str, list[str]] or None, optional
        Restrict plotting to specific node groups (e.g., observed,
        latent). Defaults to all nodes.
    node_latent_show : bool, optional
        If ``False``, omit latent nodes while preserving their effects via
        arcs. Defaults to ``True``.
    show_labels : bool, optional
        Display node labels when ``True`` (default).
    use_labels : bool, optional
        When ``True`` (default), prefer custom labels over node names.

    node_ : dict or scalar or None, optional
        Control the visual attributes of nodes. Can be applied per node,
        per group based on node role, or to all nodes.
        Which case happends depends on the input:

        * str, float, int -> apply to all nodes
        * None   -> use defaults based on GCM styles by type (see causalinf.gcm.styles())
        * dict   -> apply to nodes or types based on the keys, which can be:

            - Node Role: 'Exposure', "Outcome", "Latent", "Observed", or any user-defined node role
            - Node name

        Accepted values for each parameter:

        *  _shape: ``str``
        *  _size: int, ``float``
        *  _color: ``str``

        *  _border_color: ``str``
        *  _border_style: ``str`` ('-', 'solid', '--', 'dashed', ":", 'dotted')
        *  _border_width: ``int, float``

        *  _label_color: ``str``
        *  _label_fontsize: ``int, float``
        *  _label_fontweight: ``str`` (normal, bold, italic)
        *  _label_adj_x: int, ``float``
        *  _label_adj_y: int, ``float``
        *  _label_box_style: ``str`` ("round"')
        *  _label_box_margin: ``int, float``

    node_latent_show: bool
        If True, show latent nodes

    node_label_box: bool, optional
        If True, draw box around the label when using 'rectangle' node style.

    edge_  : dict or scalar or None, optional
        Control the visual attributes of edges. Can be applied per edge,
        per edge type, or to all edges. Which case happends depends on the input:

        - scalar -> apply to all edges
        - None   -> use defaults by edge type
        - dict   -> keys can be:
            * edge type (case-insensitive):
                * 'directed' -> apply to all directed edges
                * 'bidirected' -> apply to all bidirected edges
                * 'undirected'  -> apply to all undirected edges
            * actual edges. Example:
                - ('D', 'Y') apply to the "D -> Y" directed edge
                - (('D', 'Y'), ('Y', 'D')) apply to the "D <-> Y" bidirected edge
                - frozenset({'D', 'Y'}) apply to the "D -- Y" undirected edge

        Accepted values for each parameter:

        * _color: ``str``
        * _style: ``str`` ('-', 'solid', '--', 'dashed', ":", 'dotted')
        * _arc: ``float``
        * _linewidth: ``float``
        * _head_size: ``float``
        * _head_style: ``str`` ('->', '-|>')
        * _margin_tail: ``float``
        * _margin_head: ``float``

        * _label: ``str``
        * _label_color_background: ``str``
        * _label_color_border: ``str``
        * _label_size: ``float``
        * _label_color: ``str``
        * _label_alpha: ``float``
        * _label_rotate: bool
        * _label_position:  ``float``

    edge_subset : dict[str, list] or None, optional
        Limit plotting to selected edges by type.

    edge_label_estimates_sig_level : float, optional
        Significance level used when estimates include confidence bounds.
    edge_label_estimates_colors : dict or None, optional
        Colors for negative and positive estimate labels. Use ``None`` to
        keep the default edge label color. Defaults to
        ``{"negative": "red", "positive": "blue"}``.
    edge_label_estimates_face : dict or None, optional
        Font weight for negative and positive estimate labels, e.g.
        ``{"negative": "normal", "positive": "bold"}``. Use ``None`` to
        keep the normal label weight.
    edge_label_estimates_show_sig : bool, optional
        Append significance stars from the estimates summary when ``True``.
        Defaults to ``True``.
    edge_label_estimates_show_sig_alpha : dict or None, optional
        Alpha values keyed by ``"Yes"`` and ``"No"``, where ``"Yes"``
        means the estimate p-value is at or below
        ``edge_label_estimates_sig_level``. Use ``None`` to keep the
        default edge label alpha. Defaults to ``{"Yes": .5, "No": 1}``.
    edge_label_estimates_show_ci : bool, optional
        Add confidence intervals below the estimate label when ``True``.
        Defaults to ``False``.
    edge_label_estimates_show_ci_round : int, optional
        Number of decimal places used for confidence interval bounds.
        Defaults to ``4``.

    edge_label_pvalue : dict or None, optional
        P-value annotations keyed by edge.

    edge_label_font_family : str or None, optional
        Font family for edge labels.

    legend_show : bool, optional
        Display the legend when ``True`` (default).
    legend_title : str, optional
        Legend title. Defaults to ``'Nodes'``.
    legend_title_align : {'left', 'center', 'right'}, optional
        Horizontal alignment for the legend title.
    legend_title_weight : str, optional
        Font weight for the legend title.
    legend_title_size : int, optional
        Legend title font size.
    legend_omit_cases : list[str], optional
        Node role labels to omit from the legend.
    legend_keys : dict or None, optional
        Custom legend entries keyed by role.
    legend_loc : str, optional
        Legend placement for ``matplotlib.axes.Axes.legend``.
    legend_fontsize : int, optional
        Legend text size.
    legend_frame : bool, optional
        Draw a frame around the legend when ``True``.
    legend_kws : dict, optional
        Additional keyword arguments forwarded to ``legend``.
    title : str or None, optional
        Plot title.
    title_loc : {'left', 'center', 'right'}, optional
        Title alignment. Defaults to ``'left'``.
    title_kws : dict, optional
        Additional title styling options.
    figsize : Sequence[float], optional
        Width and height (in inches) for the created figure. Defaults to
        ``[6, 4]``.
    usetex : bool, optional
        Enable LaTeX rendering for text. Defaults to ``True``.
    ax : matplotlib.axes.Axes or None, optional
        Existing axis to draw on. A new figure and axis are created when
        ``None``.
    show_plot : bool or None, optional
        Override global option controlling whether ``plt.show()`` is called.
    *args :
        Additional positional arguments forwarded to the internal plotting
        helpers.
    **kws :
        Extra keyword arguments forwarded to the internal plotting helpers.

    Returns
    -------
    matplotlib.axes.Axes
        plot object and axis on which the graph is drawn.

    Examples
    --------
    >>> G = DAG(graph="X -> Y")
    >>> plt, ax = G.plot(figsize=(4, 3), show_plot=False)
    True

    >>> dag  = '''
    >>> D -> M1
    >>> M1 -- M2
    >>> M2 -> Y
    >>> M3 -> Y
    >>> D <-> Y
    >>> D  -> Y
    >>> Z -> {D, Y}
    >>> '''
    >>> pos = {'D': (0,0),
    >>>        'Y': (1,0),
    >>>        'Z': (.5, -1),
    >>>        'M1': (.25, 1),
    >>>        'M2': (.75, 1),
    >>>        'M3': (1.75, 1),
    >>>        }
    >>> pos2 = {'D': (.5,0),
    >>>        'Y': (1,0),
    >>>        'Z': (.5, -1),
    >>>        'M1': (.25, 1),
    >>>        'M2': (.75, 1),
    >>>        'M3': (1.75, 1),
    >>>        }
    >>> roles = {'Exposure': "D",
    >>>          'Outcome' : "Y",
    >>>          "Latent"  : 'Z',
    >>>          "M2 role" : "M2"
    >>>          }
    >>> labels = {"D": "$\widetilde{D}$",
    >>>           "M1":'$M_1$',
    >>>           'Y': "Outcome"}
    >>> labels2 = {"D": "$\widetilde{D}_i$"}
    >>> edge_label = {('D', 'M1') : 1,
    >>>               ('M2', 'Y') : -1,
    >>>               ('M3', 'Y') : 'a',
    >>>               ('D', 'Y') : 'bsd;fkajsd;',
    >>>               ('Z', 'D') : '$\\beta$',
    >>>               ('Z', 'Y'): 'asccc',
    >>>               (('D', 'Y'), ('Y', 'D')): 'abc',
    >>>                # ('M2', 'M1') : 1234, # no label for undireted edges
    >>>               }
    >>> 
    >>> G = gcm.DAG(dag,  nodes_role=roles, nodes_position=pos, nodes_label=labels)  # 
    >>> G.plot()
    >>> 
    >>> G.plot(node_color='red')
    >>> G.plot(node_color={'D':'red'})
    >>> G.plot(node_border_color={'D':'red'})
    >>> G.plot(node_border_color={'Z':'red'})
    >>> G.plot(node_border_color={'Z':'red'}, node_border_style={'D':':'})
    >>> G.plot(node_border_color={'Z':'red'}, node_border_style={'D':':', 'Z':'solid'})
    """
    from . import scm as causalinf_scm

    assert estimates is None or isinstance(estimates, causalinf_scm.estimate), (
        "'estimates' must be either None or an object of causalinf.scm.estimate ")
    assert isinstance(latex_packages, list) or latex_packages is None, "latex_packages must be None or a list"

    default_usetex = plt.rcParams["text.usetex"] 
    plt.rcParams["text.usetex"] = usetex
    latex_packages_base = ["amsmath", "amssymb", "siunitx", "bm", "wasysym", "marvosym"]
    packages = latex_packages_base + (latex_packages or [])
    plt.rcParams['text.latex.preamble'] = rf"\usepackage{{{', '.join(packages)}}}"

    show_plot = show_plot if not None else get_options('show_plot')

    # collect arguments
    pars = dict(locals())      # {'node_position':..., 'arg2':..., 'args':(...), 'kws':{...}}
    args = pars.pop('args') # extra positional
    kws  = pars.pop('kws')  # extra keyword

    estimate_label_sign = {}
    estimate_label_pvalue = {}

    # use estimates as labels
    if estimates is not None:
        edge_label, edge_label_pvalue, estimate_label_sign = (
            self.__plot_collect_labels_estimate__(
                estimates,
                show_sig=edge_label_estimates_show_sig,
                show_ci=edge_label_estimates_show_ci,
                show_ci_round=edge_label_estimates_show_ci_round
            )
        )
        estimate_label_pvalue = edge_label_pvalue

    # figure 
    # ------
    G_draw = self.__plot_create_nx__()
    if ax is None:
        fig, ax = plt.subplots(figsize=figsize, tight_layout=True)
    plt.sca(ax)

    # styles
    # ------
    graph_style = graph_style or get_options('graph_style')
    style_dict = resolve_graph_style(graph_style, GRAPH_STYLES)

    # nodes 
    # -----
    node_subset       = self.__plot_nodes_subset__(node_subset, node_latent_show)
    nodes_position    = self.__plot_nodes_positions__(G_draw, nodes_position)
    node_size         = self._plot_parse_aes_node('node_size', node_size, style_dict)
    node_color        = self._plot_parse_aes_node('node_color', node_color, style_dict)
    node_shape        = self._plot_parse_aes_node('node_shape', node_shape, style_dict)
    node_border_width = self._plot_parse_aes_node('node_border_width', node_border_width, style_dict)
    node_border_color = self._plot_parse_aes_node('node_border_color', node_border_color, style_dict)
    node_border_style = self._plot_parse_aes_node("node_border_style", node_border_style, style_dict)

    for _, nodes in node_subset.items():
        for node in nodes:
            fig_nodes = nx.draw_networkx_nodes(
                G_draw,
                nodes_position,
                nodelist=[node],
                ax=ax,
                # 
                node_size  = node_size[node],
                node_color = node_color[node],
                node_shape = node_shape[node],
                linewidths = node_border_width[node],
                edgecolors = node_border_color[node],
                alpha      = None,
                cmap       = None,
                vmin       = None,
                vmax       = None,
                label      = None,
                margins    = None, 
                hide_ticks = True
            )
            fig_nodes.set_linestyle(node_border_style[node])

    # nodes labels 
    # ------------
    if show_labels:
        nodes = set(itertools.chain.from_iterable(node_subset.values()))
        nodes_label = self.nodes_label | (nodes_label or {})
        adj_x = self.__plot_label_adj__(node_label_adj_x, nodes_label)
        adj_y = self.__plot_label_adj__(node_label_adj_y, nodes_label)

        fc        = self._plot_parse_aes_node('node_color', node_color, style_dict)
        fontweight= self._plot_parse_aes_node('node_label_fontweight', node_label_fontweight, style_dict)
        fontsize  = self._plot_parse_aes_node('node_label_fontsize', node_label_fontsize, style_dict)
        boxstyle  = self._plot_parse_aes_node('node_label_box_style', node_label_box_style, style_dict)
        boxmargin = self._plot_parse_aes_node('node_label_box_margin', node_label_box_margin, style_dict)

        ec        = self._plot_parse_aes_node('node_border_color', node_border_color, style_dict)
        lw        = self._plot_parse_aes_node('node_border_width', node_border_width, style_dict)
        linestyle = self._plot_parse_aes_node('node_border_style', node_border_style, style_dict)
        node_label_box = self._plot_parse_aes_node('node_label_box', node_label_box, style_dict)

        for node in nodes:
            label = nodes_label.get(node, node) if use_labels else node
            role  = self.nodes_info[node]['role']
            x, y  = nodes_position[node] if nodes_position and all(nodes_position[node]) else \
                self.nodes_info[node]['position'] 

            if node_label_box[node]:
                bbox = {"boxstyle": f"{boxstyle[node]},pad={boxmargin[node]}",
                        "fc": fc[node],
                        "ec": ec[node],
                        "lw": lw[node],
                        "linestyle": linestyle[node],
                        "alpha": 1
                        }
            else:
                bbox = None

            if fontweight[node]=='bold':
                label = f"\\textbf{{{label}}}"
            elif fontweight[node]=='italic':
                label = f"\\textit{{{label}}}"

            plt.text(x + adj_x[node],
                     y + adj_y[node],
                     label,
                     fontweight = 'normal',
                     fontsize   = fontsize[node],
                     ha = 'center',
                     va = 'center',
                     bbox = bbox)

    # edges and edges labels
    # ----------------------
    nodes = set(itertools.chain.from_iterable(node_subset.values()))

    style            = self._plot_parse_aes_edge("edge_style", edge_style, style_dict)
    color            = self._plot_parse_aes_edge("edge_color", edge_color, style_dict)
    arc              = self._plot_parse_aes_edge("edge_arc", edge_arc, style_dict)
    width            = self._plot_parse_aes_edge("edge_linewidth", edge_linewidth, style_dict)
    arrow_head_size  = self._plot_parse_aes_edge("edge_head_size", edge_head_size, style_dict)
    arrow_head_style = self._plot_parse_aes_edge("edge_head_style", edge_head_style, style_dict)
    edge_margin_head = self._plot_parse_aes_edge("edge_margin_head", edge_margin_head, style_dict)
    edge_margin_tail = self._plot_parse_aes_edge("edge_margin_tail", edge_margin_tail, style_dict)


    edge_label_alpha    = self._plot_parse_aes_edge("edge_label_alpha", edge_label_alpha, style_dict)
    edge_label_size     = self._plot_parse_aes_edge("edge_label_size", edge_label_size, style_dict)
    edge_label_color    = self._plot_parse_aes_edge("edge_label_color", edge_label_color, style_dict)
    edge_label_rotate   = self._plot_parse_aes_edge("edge_label_rotate", edge_label_rotate, style_dict)
    edge_label_position = self._plot_parse_aes_edge("edge_label_position", edge_label_position, style_dict)
    edge_label_color_border     = self._plot_parse_aes_edge("edge_label_color_border", edge_label_color_border, style_dict)
    edge_label_color_background = self._plot_parse_aes_edge("edge_label_color_background", edge_label_color_background, style_dict)
    edge_label_font_weight = {edge: 'normal' for edge in edge_label_color}

    if estimates is not None:
        edge_label_color = self.__plot_apply_estimate_sign_feature__(
            edge_label_color,
            estimate_label_sign,
            edge_label_estimates_colors
        )
        edge_label_font_weight = self.__plot_apply_estimate_sign_feature__(
            edge_label_font_weight,
            estimate_label_sign,
            edge_label_estimates_face
        )
        edge_label_alpha = self.__plot_apply_estimate_sig_alpha__(
            edge_label_alpha,
            estimate_label_pvalue,
            edge_label_estimates_show_sig_alpha,
            edge_label_estimates_sig_level
        )

    for edge_type in ['directed', 'bidirected', 'undirected']:
        for edge in self.__getattribute__(edge_type):

            if edge_type == 'directed':
                u, v = tuple(edge)
            elif edge_type=='bidirected':
                u, v = edge[0]
            elif edge_type=='undirected':
                u, v = tuple(edge)
                edge = frozenset(edge)

            if edge_subset:
                e = set(edge) if edge_type=='undirected' else edge
                show_edge = self.edge_exist(e, edge_subset.get(edge_type, []))
            else:
                show_edge = True

            if u in nodes and v in nodes and show_edge:
                # edge
                nx.draw_networkx_edges(
                    G_draw,
                    nodes_position,
                    edgelist            = [(u, v)],
                    nodelist            = [u, v],
                    node_size           = [node_size[u], node_size[v]],
                    style               = style[edge],
                    edge_color          = color[edge],
                    connectionstyle     = f"arc3,rad={arc[edge]}",
                    arrows              = True,
                    arrowstyle          = arrow_head_style[edge],
                    arrowsize           = arrow_head_size[edge],
                    min_source_margin   = edge_margin_tail[edge],
                    min_target_margin   = edge_margin_head[edge],
                    width               = width[edge],
                    ax=ax)

                # edge label
                edge_label = edge_label or self.edge_label
                label = edge_label.get(edge, '')
                rotate = edge_label_rotate if edge_label_rotate is not None else True # must keep "is not None" here
                nx.draw_networkx_edge_labels(
                    G_draw,
                    pos         = nodes_position,
                    edge_labels = {(u, v): label},
                    bbox        = dict(facecolor=edge_label_color_background[edge],
                                       edgecolor=edge_label_color_border[edge]),
                    alpha       = edge_label_alpha[edge],
                    font_size   = edge_label_size[edge], 
                    font_color  = edge_label_color[edge], 
                    font_weight = edge_label_font_weight[edge],
                    rotate      = edge_label_rotate[edge], 
                    label_pos   = edge_label_position[edge], 
                    font_family = edge_label_font_family,
                    connectionstyle = f"arc3,rad={arc[edge]}",
                    ax          = ax
                )

    # legend (aggreagate per role, not per node)
    # ------
    if legend_show:
        keys = []
        for role, nodes in node_subset.items():
            if role not in legend_omit_cases:
                # collect aes for all latent nodes
                marker          = []
                color           = []
                markeredgecolor = []
                markerfacecolor = []
                linestyle       = []
                for i, node in enumerate(nodes):
                    linestyle       += [node_border_style[node]]
                    marker          += [''] if linestyle[i] in ['--', 'dotted', 'dashed', ':'] else ['o']
                    color           += [node_border_color[node]]#['black'] if role == 'Latent' else ['white']
                    markeredgecolor += [node_border_color[node]]
                    markerfacecolor += [node_color[node]]

                # add only unique aes to legend
                for marker, color, markeredgecolor, markerfacecolor, linestyle in \
                        set(zip(marker, color, markeredgecolor, markerfacecolor, linestyle)):
                    keys += [
                        Line2D(
                            [0], [0],
                            marker=marker,
                            color = color,
                            label = role,
                            markersize = 10,
                            markeredgecolor=markeredgecolor,
                            markerfacecolor=markerfacecolor,
                            linestyle=linestyle
                        )]
        if keys: 
            legend = plt.legend(handles        = keys,
                                title          = legend_title,
                                title_fontsize = legend_title_size,
                                alignment      = legend_title_align,
                                # title_weight   = legend_title_weight,
                                loc            = legend_loc,
                                fontsize       = legend_fontsize,
                                frameon        = legend_frame,
                                **legend_kws
                                )
            if legend_title_weight=='bold' and legend_title:
                legend.set_title(title=f'\\textbf{{{legend_title}}}', prop={'weight': 'bold'})

    # title 
    # -----
    if title:
        plt.title(label=title, loc=title_loc, **title_kws)

    plt.axis("off")
    plt.tight_layout()
    if show_plot:
        plt.show()
    plt.rcParams["text.usetex"] = default_usetex

    return plt, ax