GraphWidget

Class

The main widget class.

To be used in jupyter-notebook or jupyter-lab.

Example

from yfiles_jupyter_graphs import GraphWidget
w = GraphWidget()
w.show()

See notebooks for more examples.

Notes

Nodes and edges properties should be constructed recursively with basic python types otherwise {de-}serializers will fail.

Properties

`nodes: typing.List[typing.Dict]`

Data structure.

def get_nodes()
Getter for the nodes traitlets property.

Notes

This function acts as an alias for using GraphWidget.nodes property e.g. w.nodes == w.get_nodes().

Returns

Name	Type	Description
`nodes`	`typing.List[typing.Dict]`	Each node has the keys `id: int` and `properties: typing.Dict`. It might include keys that are not set directly, see (default) node mappings for details.

def set_nodes(nodes)
Setter for the nodes traitlets property.

Parameters

Name	Type	Description
`nodes`	`typing.List[typing.Dict]`	Each node should have the keys `id: int` and `properties: typing.Dict`. Properties should be constructed recursively with basic python types, otherwise {de-}serializers will fail.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: w.set_nodes([
            {'id': 0, 'properties': {'label': 'Hello World'}},
            {'id': 1, 'properties': {'label': 'This is a second node.'}}
        ])

Notes

This function acts as an alias for using GraphWidget.nodes property e.g. w.nodes = [{...}] has the same effect as using w.set_nodes([{...}]).

`edges: typing.List[typing.Dict]`

Data structure.

def get_edges()
Getter for the edges traitlets property.

Notes

This function acts as an alias for using GraphWidget.edges property e.g. w.edges == w.get_edges() is true.

Returns

Name	Type	Description
`edges`	`typing.List[typing.Dict]`	Each edge has the keys `id: int`, `start: int`, `end: int` and `properties: typing.Dict`. It might include keys that are not set directly, see (default) edge mappings for details.

def set_edges(edges)
Setter for the edges traitlets property.

Parameters

Name	Type	Description
`edges`	`typing.List[typing.Dict]`	Each edge should have the keys `id: int`, `start: int`, `end:int` and `properties: typing.Dict`. Ids for start and end should be among used node ids, otherwise the edge does not appear. Properties should be constructed recursively with basic python types, otherwise {de-}serializers will fail.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: w.set_edges([
            {'id': 0, 'start': 0, 'end': 1, 'properties': {'label': 'edge between first and second node'}}
        ])

Notes

This function acts as an alias for using GraphWidget.edges property e.g. w.edges = [{...}] has the same effect as using w.set_edges([{...}]).

`directed: bool`

Graph wide flag for edge type.

def get_directed()
Getter for the directed traitlets property.

Notes

This function acts as an alias for using GraphWidget.directed property e.g. w.directed == w.get_directed() is true.

Returns

Name	Type	Description
`directed`	`bool`	Whether the graph is interpreted as directed.

def set_directed(directed)
Setter for the directed traitlets property.

Parameters

Name	Type	Description
`directed`	`bool`	Whether the graph is interpreted as directed.

Notes

This function acts as an alias for using GraphWidget.directed property e.g. w.directed = x has the same effect as using w.set_directed(x).

This function acts as an alias for using GraphWidget.graph_layout property\ e.g. w.graph_layout = 'organic' has the same effect as using w.set_graph_layout('organic').\ Setting w.graph_layout = {'algorithm': 'organic', 'options': {}} works as well,\ which corresponds to using value given through the associated getter.\ In case you want to use the edge routers\ you should set a custom node position mapping as well.

See yFiles docs for more details about the algorithms.

`neighborhood: typing.Dict`

Control neighborhood view component.

def get_neighborhood()
Getter for the neighborhood traitlets property.

Returns

Name	Type	Description
`neighborhood`	`typing.Dict`	Returned dict has keys max_distance: int and selected_nodes: list, a list of node ids.

def set_neighborhood(max_distance, selected_nodes)
Specify the neighborhood view in the widget.

The number of hops and focused nodes can be chosen.

Parameters

Name	Type	Description
`max_distance`	`int`	Set the maximum distance between selected and included nodes. If there are multiple paths to one (or multiple) selected nodes, the smallest path length is considered for this threshold.
`selected_nodes`	`typing.List` (optional)	Choose a list of node ids that are highlighted in both main and neighborhood component. They act as starting points for neighborhood calculation.

Notes

This function acts as an alias for using GraphWidget.neighborhood property.\ You can assign values by w.neighborhood = {'max_distance': 2, 'selected_nodes':[2]}\ or w.set_neighborhood(2, [2]), both are equivalent.\ The short form w.neighborhood = 3 sets only the max_distance variable\ and resets the selected nodes.

Control sidebar component.

def get_sidebar()
Getter for the sidebar traitlets property.

Returns

Name	Type	Description
`sidebar`	`typing.Dict`	Returned dict has keys enabled: bool and start_with: str, whereat first one indicates open or closed sidebar and second one indicates start panel on widget show.

def set_sidebar(enabled, start_with)
Specify the appearance of the sidebar in the widget.

Can be used to collapse sidebar or start with any panel.

Parameters

Name	Type	Description
`enabled`	`bool`	Whether to open or collapse sidebar at widget startup.
`start_with`	`str`	The start panel identifier. Available are 'Neighborhood', 'Data', 'Search' and 'About' (the default).

Notes

This function acts as an alias for using GraphWidget.sidebar property.\ You can assign values by w.sidebar = {'enabled': True, 'start_with': 'Search'}\ or w.set_sidebar(True, 'Search'), both are equivalent.\ The short form w.sidebar = True sets only the enabled variable\ and resets the start_with back to the default.

`overview: bool`

Control overview component.

def get_overview()
Getter for the overview traitlets property.

Returns

Name	Type	Description
`overview`	`bool`	Indicates open or closed overview state. A value of None means that a specific behaviour based on widget layout is followed.

def set_overview(enabled)
Specify the appearance of the overview component in the widget.

Can be used to force open overview in case of a small widget layout or\ force collapsed overview in case of large widget layout.

Parameters

Name	Type	Description
`enabled`	`bool`	Whether to open or collapse overview at widget startup.

`node_label_mapping: Union[callable, str]`

Data dependent change of node label on a per node basis.

def get_node_label_mapping()
Getter for the node label mapping property.

Notes

If no mapping is explicitly set, default_node_label_mapping is returned.

Returns

Name	Type	Description
`node_label_mapping`	`Union[callable, str]`	A function that produces node labels or the name of the property to use for binding.

def set_node_label_mapping(node_label_mapping)
Setter for the node label mapping property.

Parameters

Name	Type	Description
`node_label_mapping`	`Union[callable, str]`	A function that produces node labels or the name of the property to use for binding. The function should have the same signature as `default_node_label_mapping` e.g. take in an index and node dictionary and return a string.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_node_label_mapping(index: int, node: dict):
         ...
In [4]: w.set_node_label_mapping(custom_node_label_mapping)

def del_node_label_mapping()
Deleter for the name property.

Remove a custom node label mapping.

`edge_label_mapping: Union[callable, str]`

Data dependent change of edge label on a per edge basis.

def get_edge_label_mapping()
Getter for the edge label mapping property.

Notes

If no mapping is explicitly set, default_edge_label_mapping is returned.

Returns

Name	Type	Description
`edge_label_mapping`	`Union[callable, str]`	A function that produces edge labels or the name of the property to use for binding.

def set_edge_label_mapping(edge_label_mapping)
Setter for the edge label mapping property.

Parameters

Name	Type	Description
`edge_label_mapping`	`Union[callable, str]`	A function that produces edge labels or the name of the property to use for binding. The funtion should have the same signature as `default_edge_label_mapping` e.g. take in an index and edge dictionary and return a string.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_edge_label_mapping(index: int, node: dict):
         ...
In [4]: w.set_edge_label_mapping(custom_edge_label_mapping)

def del_edge_label_mapping()
Deleter for the edge label mapping property.

Remove a custom edge label mapping.

`node_property_mapping: Union[callable, str]`

Data dependent change of node properties on a per node basis.

def get_node_property_mapping()
Getter for the node property mapping property.

Notes

If no mapping is explicitly set, default_node_property_mapping is returned.

Returns

Name	Type	Description
`node_property_mapping`	`Union[callable, str]`	A function that produces node properties or the name of the property to use for binding.

def set_node_property_mapping(node_property_mapping)
Setter for the node property mapping property.

Parameters

Name	Type	Description
`node_property_mapping`	`Union[callable, str]`	A function that produces node properties or the name of the property to use for binding. The function should have the same signature as `default_node_property_mapping` e.g. take in an index and node dictionary and return a dictionary.

Notes

Properties are changed inplace by this mapping.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_node_property_mapping(index: int, node: dict):
         ...
In [4]: w.set_node_property_mapping(custom_node_property_mapping)

def del_node_property_mapping()
Deleter for the node property mapping property.

Remove a custom node property mapping.

`edge_property_mapping: Union[callable, str]`

Data dependent change of edge properties on a per edge basis.

def get_edge_property_mapping()
Getter for the edge property mapping property.

Notes

If no mapping is explicitly set, default_edge_property_mapping is returned.

Returns

Name	Type	Description
`edge_property_mapping`	`Union[callable, str]`	A function that produces edge properties or the name of the property to use for binding.

def set_edge_property_mapping(edge_property_mapping)
Setter for the edge property mapping property.

Parameters

Name	Type	Description
`edge_property_mapping`	`Union[callable, str]`	A function that produces edge properties or the name of the property to use for binding. The function should have the same signature as `default_edge_property_mapping` e.g. take in an index and edge dictionary and return a dictionary.

Notes

Properties are changed inplace by this mapping.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_edge_property_mapping(index: int, node: dict):
         ...
In [4]: w.set_edge_property_mapping(custom_edge_property_mapping)

def del_edge_property_mapping()
Deleter for the edge property mapping property.

Remove a custom edge property mapping.

`node_color_mapping: Union[callable, str]`

Data dependent change of node color on a per node basis.

def get_node_color_mapping()
Getter for the node color mapping property.

Notes

If no mapping is explicitly set, default_node_color_mapping is returned.

Returns

Name	Type	Description
`node_color_mapping`	`Union[callable, str]`	A function that produces node colors or the name of the property to use for binding.

def set_node_color_mapping(node_color_mapping)
Setter for the node color mapping property.

Parameters

Name	Type	Description
`node_color_mapping`	`Union[callable, str]`	A function that produces node colors or the name of the property to use for binding. The function should have the same signature as `default_node_color_mapping` e.g. take in an index and node dictionary and return a string.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_node_color_mapping(index: int, node: dict):
         ...
In [4]: w.set_node_color_mapping(custom_node_color_mapping)

def del_node_color_mapping()
Deleter for the node color mapping property.

Remove a custom node color mapping.

`node_styles_mapping: Union[callable, str]`

Data dependent change of node styles on a per node basis.

def get_node_styles_mapping()
Getter for the node styles mapping property.

Notes

If no mapping is explicitly set, default_node_styles_mapping is returned.

Returns

Name	Type	Description
`node_styles_mapping`	`Union[callable, str]`	A function that produces node styles or the name of the property to use for binding.

def set_node_styles_mapping(node_styles_mapping)
Setter for the node styles mapping property.

Parameters

Name	Type	Description
`node_styles_mapping`	`Union[callable, str]`	A function that produces node styles or the name of the property to use for binding. The function should have the same signature as `default_node_styles_mapping` e.g. take in an index and node dictionary and return a string.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_node_styles_mapping(index: int, node: dict):
         ...
In [4]: w.set_node_styles_mapping(custom_node_styles_mapping)

def del_node_styles_mapping()
Deleter for the node styles mapping property.

Remove a custom node styles mapping.

`edge_color_mapping: Union[callable, str]`

Data dependent change of edge color on a per edge basis.

def get_edge_color_mapping()
Getter for the edge color mapping property.

Notes

If no mapping is explicitly set, default_edge_color_mapping is returned.

Returns

Name	Type	Description
`edge_color_mapping`	`Union[callable, str]`	A function that produces edge colors or the name of the property to use for binding.

def set_edge_color_mapping(edge_color_mapping)
Setter for the edge color mapping property.

Parameters

Name	Type	Description
`edge_color_mapping`	`Union[callable, str]`	A function that produces edge colors or the name of the property to use for binding. The function should have the same signature as `default_edge_color_mapping` e.g. take in an index and edge dictionary and return a string.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_edge_color_mapping(index: int, node: dict):
         ...
In [4]: w.set_edge_color_mapping(custom_edge_color_mapping)

def del_edge_color_mapping()
Deleter for the edge color mapping property.

Remove a custom edge color mapping.

`node_scale_factor_mapping: Union[callable, str]`

Data dependent change of node scale factor on a per node basis.

def get_node_scale_factor_mapping()
Getter for the node scale factor mapping property.

Notes

If no mapping is explicitly set, default_node_scale_factor_mapping is returned.

Returns

Name	Type	Description
`node_scale_factor_mapping`	`Union[callable, str]`	A function that produces node scale factor or the name of the property to use for binding.

def set_node_scale_factor_mapping(node_scale_factor_mapping)
Setter for the node scale factor mapping property.

Parameters

Name	Type	Description
`node_scale_factor_mapping`	`Union[callable, str]`	A function that produces node scale factors or the name of the property to use for binding. The function should have the same signature as `default_node_scale_factor_mapping` e.g. take in an index and node dictionary and return a positive float.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_node_scale_factor_mapping(index: int, node: dict):
         ...
In [4]: w.set_node_scale_factor_mapping(custom_node_scale_factor_mapping)

def del_node_scale_factor_mapping()
Deleter for the node scale factor mapping property.

Remove a custom node scale factor mapping.

`edge_thickness_factor_mapping: Union[callable, str]`

Data dependent change of edge thickness factor on a per edge basis.

def get_edge_thickness_factor_mapping()
Getter for the edge thickness factor mapping property.

Notes

If no mapping is explicitly set, default_edge_thickness_factor_mapping is returned.

Returns

Name	Type	Description
`edge_thickness_factor_mapping`	`Union[callable, str]`	A function that produces edge thickness factors or the name of the property to use for binding.

def set_edge_thickness_factor_mapping(edge_thickness_factor_mapping)
Setter for the edge thickness factor mapping property.

Parameters

Name	Type	Description
`edge_thickness_factor_mapping`	`Union[callable, str]`	A function that produces edge thickness factors or the name of the property to use for binding. The function should have the same signature as `default_edge_thickness_factor_mapping` e.g. take in an index and edge dictionary and return a positive float.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_edge_thickness_factor_mapping(index: int, node: dict):
         ...
In [4]: w.set_edge_thickness_factor_mapping(custom_edge_thickness_factor_mapping)

def del_edge_thickness_factor_mapping()
Deleter for the edge thickness factor mapping property.

Remove a custom edge thickness factor mapping.

`node_type_mapping: Union[callable, str]`

Data dependent change of node type on a per node basis.

def get_node_type_mapping()
Getter for the node type mapping property.

Notes

If no mapping is explicitly set, default_node_type_mapping is returned.

Returns

Name	Type	Description
`node_type_mapping`	`Union[callable, str]`	A function that produces node types or the name of the property to use for binding.

def set_node_type_mapping(node_type_mapping)
Setter for the node type mapping property.

Parameters

Name	Type	Description
`node_type_mapping`	`Union[callable, str]`	A function that produces node types or the name of the property to use for binding. The function should have the same signature as `default_node_type_mapping` e.g. take in an index and node dictionary and return a bool/int/float or str value.

Notes

Node types give more information for some layout algorithms.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_node_type_mapping(index: int, node: dict):
         ...
In [4]: w.set_node_type_mapping(custom_node_type_mapping)

References

Layout with Custom Node Types

def del_node_type_mapping()
Deleter for the node type mapping property.

Remove a custom node type mapping.

`node_position_mapping: Union[callable, str]`

Data dependent change of node position on a per node basis.

def get_node_position_mapping()
Getter for the node position mapping property.

Notes

If no mapping is explicitly set, default_node_position_mapping is returned.

Returns

Name	Type	Description
`node_position_mapping`	`Union[callable, str]`	A function that produces node positions or the name of the property to use for binding.

def set_node_position_mapping(node_position_mapping)
Setter for the node position mapping property.

Parameters

Name	Type	Description
`node_position_mapping`	`Union[callable, str]`	A function that produces node positions or the name of the property to use for binding. The function should have the same signature as `default_node_position_mapping` e.g. take in an index and node dictionary and return a float 2-tuple.

Notes

Only edge router algorithms consider node positions,\ all other algorithms calculate node positions themselves.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_node_position_mapping(index: int, node: dict):
         ...
In [4]: w.set_node_position_mapping(custom_node_position_mapping)

def del_node_position_mapping()
Deleter for the node position mapping property.

Remove a custom node position mapping.

`directed_mapping: Union[callable, str]`

Data dependent change if an edge is directed or not.

def get_directed_mapping()
Getter for the directed mapping property.

Notes

If no mapping is explicitly set, default_directed_mapping is returned.

Returns

Name	Type	Description
`directed_mapping`	`Union[callable, str]`	A function that produces edge directions or the name of the property to use for binding.

def set_directed_mapping(directed_mapping)
Setter for the directed mapping property.

Parameters

Name	Type	Description
`directed_mapping`	`Union[callable, str]`	A function that produces edge directions or the name of the property to use for binding. The function should have the same signature as `default_directed_mapping` e.g. take in an index and edge dictionary and return a boolean value.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_directed_mapping(index: int, node: dict):
         ...
In [4]: w.set_directed_mapping(custom_directed_mapping)

def del_directed_mapping()
Deleter for the directed mapping property.

Remove a custom directed mapping.

Methods

`def init(widget_layout = None, overview_enabled = None, context_start_with = '')`

GraphWidget constructor.

Parameters

Name	Type	Description
`widget_layout`	`ipywidgets.Layout` (optional)	Can be used to specify general widget appearance through css attributes. See references for a link to their documentation and available keywords.
`overview_enabled`	`bool` (optional)	Enable graph overview component. Default behaviour depends on cell width.
`context_start_with`	`str` (optional)	Specify context tab name to start with that tab opened. Default behaviour is open with About dialog. Use `None` to start with closed sidebar. Available are Neighborhood, Data, Search and About.

`def show()`

Display widget in Jupyter.

Same as using single object reference in cell directly.

Notes

Mappings will only be applied shortly before showing the widget.

`def import_graph(graph)`

Import a graph object defined in an external module.

Sets the nodes, edges and directed traitlets properties \ with information extracted from the graph object. \ See graph importers for object specific transformation details.

Parameters

Name	Type	Description
`graph`	`networkx.{Multi}{Di}Graph \\| graph_tool.Graph \\| igraph.Graph \\| pygraphviz.AGraph`	The graph data structure.

Example

In [1]: from networkx import florentine_families_graph
In [2]: from yfiles_jupyter_graphs import GraphWidget
In [3]: w = GraphWidget()
In [4]: w.import_graph(florentine_families_graph())

Notes

Some graph data structures have special attributes for labels, some don't.\ Same goes for other graph properties.\ This method and the underlying transformations should be seen as best effort\ to provide an easy way to input data into the widget.\ For more granular control use nodes and edges properties directly.

`def circular_layout()`

Alias for GraphWidget.graph_layout</a= "circular".

See yFiles circular layout guide for more details about this specific algorithm.

`def hierarchic_layout()`

Alias for GraphWidget.graph_layout</a= "hierarchic".

See yFiles hierarchic layout guide for more details about this specific algorithm.

`def organic_layout()`

Alias for GraphWidget.graph_layout</a= "organic".

See yFiles organic layout guide for more details about this specific algorithm.

`def orthogonal_layout()`

Alias for GraphWidget.graph_layout</a= "orthogonal".

See yFiles orthogonal layout guide for more details about this specific algorithm.

`def radial_layout()`

Alias for GraphWidget.graph_layout</a= "radial".

See yFiles radial layout guide for more details about this specific algorithm.

`def tree_layout()`

Alias for GraphWidget.graph_layout</a= "tree".

See yFiles tree layout guide for more details about this specific algorithm.

`def orthogonal_edge_router()`

Alias for GraphWidget.graph_layout</a= "orthogonal_edge_router".

See yFiles orthogonal edge router guide for more details about this specific algorithm.

`def organic_edge_router()`

Alias for GraphWidget.graph_layout</a= "organic_edge_router".

See yFiles organic edge router guide for more details about this specific algorithm.

`def default_element_label_mapping(index, element)`

The default property mapping for graph elements.

The default label mapping for graph elements.

Element (dict) should have key properties which itself should be a dict.\ Then one of the following values (in descending priority) is used as label: - properties["label"] - properties["yf_label"]

Parameters

Name	Type	Description
`index`	`int`	Position in corresponding nodes or edges list.
`element`	`typing.Dict`	Can be both node or edge.

Notes

This is the default value for the {node|edge}_label_mapping property.\ Can be 'overwritten' by setting the property with a function of the same signature.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_element_label_mapping(index: int, element: typing.Dict):
         ...
In [4]: w.set_{node|edge}_label_mapping(custom_element_label_mapping)

Returns

Name	Type	Description
`label`	`str`	The node or edge label.

`def default_node_label_mapping(index, node)`

The default label mapping for nodes.

See default_element_label_mapping.

`def default_edge_label_mapping(index, edge)`

The default label mapping for edges.

See default_element_label_mapping.

`def default_element_property_mapping(index, element)`

The default property mapping for graph elements.

Simply selects the properties value of element dictionary.

Parameters

Name	Type	Description
`index`	`int`	Position in corresponding nodes or edges list.
`element`	`typing.Dict`	Can be both node or edge.

Notes

This is the default value for the {node|edge}_property_mapping property.\ Can be 'overwritten' by setting the property with a function of the same signature.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_element_property_mapping(index: int, element: typing.Dict):
         ...
In [4]: w.set_{node|edge}_property_mapping(custom_element_property_mapping)

Returns

Name	Type	Description
`properties`	`typing.Dict`	The node or edge properties.

`def default_node_property_mapping(index, node)`

The default property mapping for nodes.

See default_element_property_mapping.

`def default_edge_property_mapping(index, edge)`

The default property mapping for edges.

See default_element_property_mapping.

`def default_node_color_mapping(index, node)`

The default color mapping for nodes.

Provides constant value of '#17bebb' for all nodes.

Parameters

Name	Type	Description
`index`	`int`	Position in nodes list.
`node`	`typing.Dict`

Notes

This is the default value for the node_color_mapping property.\ Can be 'overwritten' by setting the property with a function of the same signature.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_node_color_mapping(index: int, node: typing.Dict):
          ...
In [4]: w.set_node_color_mapping(custom_node_color_mapping)

Returns

Name	Type	Description
`color`	`str`	CSS color value.

References

css color value

yFiles docs Fill api

`def default_node_styles_mapping(index, node)`

The default styles mapping for nodes.

Provides constant value of {} for all nodes.

Parameters

Name	Type	Description
`index`	`int`	Position in nodes list.
`node`	`typing.Dict`

Notes

This is the default value for the node_styles_mapping property.\ Can be 'overwritten' by setting the property with a function of the same signature.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_node_styles_mapping(index: int, node: typing.Dict):
          ...
In [4]: w.set_node_styles_mapping(custom_node_styles_mapping)

Returns

Name	Type	Description
`styles`	`typing.Dict`	A `Dict` with mappings for style attributes. See below for supported values.

Supported style attributes in the return Dict:

can contain the following key-value-pairs:
    "color": str
        css color value
    "shape": str
        possible values: 'ellipse', 'hexagon', 'hexagon2', 'octagon', 'pill', 'rectangle', 'round-rectangle' or 'triangle'
    "image": str
        url or data URL of the image

References

css color value

Data URL

`def default_edge_color_mapping(index, edge)`

The default color mapping for edges.

Provides constant value of '#094c4b' for all edges.

Parameters

Name	Type	Description
`index`	`int`	Position in edges list.
`edge`	`typing.Dict`

Notes

This is the default value for the edge_color_mapping property.\ Can be 'overwritten' by setting the property with a function of the same signature.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_edge_color_mapping(index: int, edge: typing.Dict):
         ...
In [4]: w.set_edge_color_mapping(custom_edge_color_mapping)

Returns

Name	Type	Description
`color`	`str`	CSS color value.

References

css color value

yFiles docs Fill api

`def default_node_scale_factor_mapping(index, node)`

The default scale factor mapping for nodes.

Provides constant value of 1.0 for all nodes.

Parameters

Name	Type	Description
`index`	`int`	Position in nodes list.
`node`	`typing.Dict`

Notes

This is the default value for the node_scale_factor_mapping property.\ Can be 'overwritten' by setting the property with a function of the same signature.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_node_scale_factor_mapping(index: int, node: typing.Dict):
         ...
In [4]: w.set_node_scale_factor_mapping(custom_node_scale_factor_mapping)

Returns

Name	Type	Description
`node_scale_factor`	`float`	Positive scale factor.

`def default_edge_thickness_factor_mapping(index, edge)`

The default thickness factor mapping for edges.

Provides constant value of 1.0 for all edges.

Parameters

Name	Type	Description
`index`	`int`	Position in edges list.
`edge`	`typing.Dict`

Notes

This is the default value for the edge_thickness_factor_mapping property.\ Can be 'overwritten' by setting the property with a function of the same signature.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_edge_thickness_factor_mapping(index: int, edge: typing.Dict):
         ...
In [4]: w.set_edge_thickness_factor_mapping(custom_edge_thickness_factor_mapping)

Returns

Name	Type	Description
`edge_thickness_factor`	`float`	Positive thickness factor.

`def default_node_type_mapping(index, node)`

The default type mapping for nodes.

Provides constant value of None for all nodes.

Parameters

Name	Type	Description
`index`	`int`	Position in nodes list.
`node`	`typing.Dict`

Notes

This is the default value for the node_type_mapping property.\ Can be 'overwritten' by setting the property with a function of the same signature.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_node_type_mapping(index: int, node: typing.Dict):
         ...
In [4]: w.set_node_type_mapping(custom_node_type_mapping)

Returns

Name	Type	Description
`node_type`	`None`	Node Type.

`def default_node_position_mapping(index, node)`

The default position mapping for nodes.

Provides constant value of [0.0, 0.0] for all nodes.

Parameters

Name	Type	Description
`index`	`int`	Position in nodes list.
`node`	`typing.Dict`

Notes

This is the default value for the node_position_mapping property.\ Can be 'overwritten' by setting the property with a function of the same signature.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_node_position_mapping(index: int, node: typing.Dict):
         ...
In [4]: w.set_node_position_mapping(custom_node_position_mapping)

Returns

Name	Type	Description
`node_position`	`float 2-tuple`	Position in euclidian plane.

`def default_directed_mapping(index, edge)`

The default directed mapping for edges.

Uses the graph wide directed attribute for all edges.

Parameters

Name	Type	Description
`index`	`int`	Position in edges list.
`edge`	`typing.Dict`

Notes

This is the default value for the directed_mapping property.\ Can be 'overwritten' by setting the property with a function of the same signature.

Example

In [1]: from yfiles_jupyter_graphs import GraphWidget
In [2]: w = GraphWidget()
In [3]: def custom_directed_mapping(index: int, edge: typing.Dict):
         ...
In [4]: w.set_directed_mapping(custom_directed_mapping)

Returns

Name	Type	Description
`directed`	`bool`	Whether the edge is directed or not.

Name	Type	Description
`algorithm`	`str`	Specify graph layout (or edge router) algorithm. Available algorithms are: ["circular", "hierarchic", "organic", "orthogonal", "radial", "tree", "orthogonal_edge_router", "organic_edge_router"]
`**kwargs`	`typing.Dict` (optional)	Extra arguments to algorithm configuration, currently ignored.