绘图仪 API 参考

以下Python API参考文档是关于核心图形抽象的三个视图，Plottable：

• 混合了所有层（如插件）的graphistry.plotter.Plotter类

• graphistry.Plottable 是核心 Graphistry 图形对象的抽象接口

• 实现它的graphistry.PlotterBase类

绘图器类

Graphistry 的主绘图器类。

此类表示Graphistry中的图，并作为绘图和分析图的主要接口。 它继承自多个mixin，允许其通过额外的图计算、布局、条件格式化等功能扩展其功能。

Inherits:

• graphistry.PlotterBase.PlotterBase: 用于绘制图形的基础类。

• graphistry.compute.ComputeMixin: 启用与计算相关的功能，如度计算。

• graphistry.layouts.LayoutsMixin: 提供控制图形布局的方法。

• graphistry.compute.conditional.ConditionalMixin: 添加对条件图操作的支持。

• graphistry.feature_utils.FeatureMixin: 添加特征工程能力。

• graphistry.umap_utils.UMAPMixin: 集成了UMAP用于降维。

• graphistry.compute.cluster.ClusterMixin: 启用与聚类相关的功能。

• graphistry.dgl_utils.DGLGraphMixin: 将深度图学习与DGL集成。

• graphistry.text_utils.SearchToGraphMixin: 支持将搜索结果转换为图形。

• graphistry.embed_utils.HeterographEmbedModuleMixin: 添加异构图嵌入功能。

• graphistry.gremlin.GremlinMixin: 为图数据库提供Gremlin查询支持。

• graphistry.gremlin.CosmosMixin: 与Azure Cosmos DB集成。

• graphistry.gremlin.NeptuneMixin: 与AWS Neptune数据库集成。

Attributes:

所有属性都是从混入和基类继承的。

可绘图界面

class graphistry.Plottable.Plottable(*args, **kwargs)

基础类：object

DGL_graph: Any | None

base_url_client(v=None)

Parameters:

v (str | None)

Return type:

字符串

base_url_server(v=None)

Parameters:

v (str | None)

Return type:

字符串

bind(source=None, destination=None, node=None, edge=None, edge_title=None, edge_label=None, edge_color=None, edge_weight=None, edge_size=None, edge_opacity=None, edge_icon=None, edge_source_color=None, edge_destination_color=None, point_title=None, point_label=None, point_color=None, point_weight=None, point_size=None, point_opacity=None, point_icon=None, point_x=None, point_y=None)

chain(ops)

ops 是 Union[List[ASTObject], Chain]

Parameters:

ops (任意类型 | 列表[任意类型])

Return type:

Plottable

chain_remote(chain, api_token=None, dataset_id=None, output_type='all', format=None, df_export_args=None, node_col_subset=None, edge_col_subset=None, engine=None)

chain 是 Union[List[ASTObject], Chain]

Parameters:

• self (Plottable)

• chain (Any | Dict[str, None | bool | str | float | int | List[None | bool | str | float | int | List[JSONVal] | Dict[str, JSONVal]] | Dict[str, None | bool | str | float | int | List[JSONVal] | Dict[str, JSONVal]]])

• api_token (str | None)

• dataset_id (str | None)

• output_type (Literal['all', 'nodes', 'edges', 'shape'])

• format (Literal['json', 'csv', 'parquet'] | None)

• df_export_args (Dict[str, Any] | None)

• node_col_subset (List[str] | None)

• edge_col_subset (List[str] | None)

• engine (Literal['pandas', 'cudf'] | None)

Return type:

Plottable

chain_remote_shape(chain, api_token=None, dataset_id=None, format=None, df_export_args=None, node_col_subset=None, edge_col_subset=None, engine=None)

chain 是 Union[List[ASTObject], Chain]

Parameters:

• self (Plottable)

• chain (Any | Dict[str, None | bool | str | float | int | List[None | bool | str | float | int | List[JSONVal] | Dict[str, JSONVal]] | Dict[str, None | bool | str | float | int | List[JSONVal] | Dict[str, JSONVal]]])

• api_token (str | None)

• dataset_id (str | None)

• format (Literal['json', 'csv', 'parquet'] | None)

• df_export_args (Dict[str, Any] | None)

• node_col_subset (List[str] | None)

• edge_col_subset (List[str] | None)

• engine (Literal['pandas', 'cudf'] | None)

Return type:

数据框

client_protocol_hostname(v=None)

Parameters:

v (str | None)

Return type:

字符串

collapse(node, attribute, column, self_edges=False, unwrap=False, verbose=False)

Parameters:

• 节点 (字符串 | 整数)

• 属性 (字符串 | 整数)

• 列 (字符串 | 整数)

• self_edges (bool)

• unwrap (bool)

• verbose (bool)

Return type:

Plottable

compute_cugraph(alg, out_col=None, params={}, kind='Graph', directed=True, G=None)

Parameters:

• alg (str)

• out_col (str | None)

• params (dict)

• 类型 (字面量['Graph', 'MultiGraph', 'BiPartiteGraph'])

• G (任意 | 无)

compute_igraph(alg, out_col=None, directed=None, use_vids=False, params={}, stringify_rich_types=True)

Parameters:

• alg (str)

• out_col (str | None)

• directed (布尔值 | 无)

• use_vids (bool)

• params (dict)

• stringify_rich_types (bool)

Return type:

Plottable

copy()

drop_nodes(nodes)

Parameters:

节点 (任意)

Return type:

Plottable

edges(edges, source=None, destination=None, edge=None, *args, **kwargs)

Parameters:

• edges (可调用的 | 任意)

• source (str | None)

• 目的地 (str | None)

• edge (str | None)

Return type:

Plottable

encode_axis(rows=[])

Return type:

Plottable

fa2_layout(fa2_params=None, circle_layout_params=None, singleton_layout=None, partition_key=None, engine=EngineAbstract.AUTO)

Parameters:

• fa2_params (Dict[str, Any] | None)

• circle_layout_params (Dict[str, Any] | None)

• singleton_layout (可调用[[Plottable, 元组[float, float, float, float] | 任意], Plottable] | 无)

• partition_key (str | None)

• engine (EngineAbstract | str)

Return type:

Plottable

filter_edges_by_dict(filter_dict=None)

Parameters:

filter_dict (字典 | 无)

Return type:

Plottable

filter_nodes_by_dict(filter_dict=None)

Parameters:

filter_dict (dict | None)

Return type:

Plottable

from_cugraph(G, node_attributes=None, edge_attributes=None, load_nodes=True, load_edges=True, merge_if_existing=True)

Parameters:

• node_attributes (列表[字符串] | 无)

• edge_attributes (列表[字符串] | 无)

• load_nodes (bool)

• load_edges (bool)

• merge_if_existing (bool)

from_igraph(ig, node_attributes=None, edge_attributes=None, load_nodes=True, load_edges=True, merge_if_existing=True)

Parameters:

• node_attributes (列表[字符串] | 无)

• edge_attributes (列表[字符串] | 无)

• load_nodes (bool)

• load_edges (bool)

• merge_if_existing (bool)

from_networkx(G)

Parameters:

G (任意)

Return type:

Plottable

get_degrees(col='degree', degree_in='degree_in', degree_out='degree_out')

Parameters:

• col (str)

• degree_in (str)

• degree_out (str)

Return type:

Plottable

get_indegrees(col='degree_in')

Parameters:

col (str)

Return type:

Plottable

get_outdegrees(col='degree_out')

Parameters:

col (str)

Return type:

Plottable

get_topological_levels(level_col='level', allow_cycles=True, warn_cycles=True, remove_self_loops=True)

Parameters:

• level_col (str)

• allow_cycles (bool)

• warn_cycles (bool)

• remove_self_loops (bool)

Return type:

Plottable

hop(nodes, hops=1, to_fixed_point=False, direction='forward', edge_match=None, source_node_match=None, destination_node_match=None, source_node_query=None, destination_node_query=None, edge_query=None, return_as_wave_front=False, target_wave_front=None)

Parameters:

• 节点 (数据框 | 无)

• hops (int | None)

• to_fixed_point (bool)

• 方向 (str)

• edge_match (dict | None)

• source_node_match (dict | None)

• destination_node_match (dict | None)

• source_node_query (str | None)

• destination_node_query (str | None)

• edge_query (str | None)

• return_as_wave_front (bool)

• target_wave_front (DataFrame | None)

Return type:

Plottable

keep_nodes(nodes)

Parameters:

节点 (列表 | 任意)

Return type:

Plottable

layout_cugraph(layout='force_atlas2', params={}, kind='Graph', directed=True, G=None, bind_position=True, x_out_col='x', y_out_col='y', play=0)

Parameters:

• 布局 (字符串)

• params (dict)

• 类型 (字面量['Graph', 'MultiGraph', 'BiPartiteGraph'])

• G (任意 | 无)

• bind_position (bool)

• x_out_col (str)

• y_out_col (str)

• play (int | None)

layout_igraph(layout, directed=None, use_vids=False, bind_position=True, x_out_col='x', y_out_col='y', play=0, params={})

Parameters:

• 布局 (字符串)

• directed (布尔值 | 无)

• use_vids (bool)

• bind_position (bool)

• x_out_col (str)

• y_out_col (str)

• play (int | None)

• params (dict)

Return type:

Plottable

layout_settings(play=None, locked_x=None, locked_y=None, locked_r=None, left=None, top=None, right=None, bottom=None, lin_log=None, strong_gravity=None, dissuade_hubs=None, edge_influence=None, precision_vs_speed=None, gravity=None, scaling_ratio=None)

Parameters:

• play (int | None)

• locked_x (bool | None)

• locked_y (bool | None)

• locked_r (bool | None)

• left (float | None)

• top (float | None)

• right (float | None)

• 底部 (浮点数 | 无)

• lin_log (bool | None)

• strong_gravity (bool | None)

• dissuade_hubs (bool | None)

• edge_influence (float | None)

• precision_vs_speed (float | None)

• gravity (float | None)

• scaling_ratio (float | None)

materialize_nodes(reuse=True, engine=EngineAbstract.AUTO)

Parameters:

• reuse (bool)

• engine (EngineAbstract | str)

Return type:

Plottable

networkx2pandas(G)

Parameters:

G (任意)

Return type:

元组[数据框, 数据框]

nodes(nodes, node=None, *args, **kwargs)

Parameters:

• 节点 (可调用的 | 任意)

• 节点 (字符串 | 无)

Return type:

Plottable

pipe(graph_transform, *args, **kwargs)

Parameters:

graph_transform (可调用)

Return type:

Plottable

plot(graph=None, nodes=None, name=None, description=None, render='auto', skip_upload=False, as_files=False, memoize=True, extra_html='', override_html_style=None, validate=True)

Parameters:

• render (bool | Literal['auto'] | ~typing.Literal['g', 'url', 'ipython', 'databricks', 'browser'] | None)

• validate (bool)

Return type:

Plottable

protocol(v=None)

Parameters:

v (str | None)

Return type:

字符串

prune_self_edges()

Return type:

Plottable

python_remote_g(code, api_token=None, dataset_id=None, format='parquet', output_type='all', engine='cudf', run_label=None, validate=True)

Parameters:

• self (Plottable)

• code (str)

• api_token (str | None)

• dataset_id (str | None)

• format (Literal['json', 'csv', 'parquet'] | None)

• output_type (Literal['all', 'nodes', 'edges', 'shape'] | ~typing.Literal['table', 'shape'] | ~typing.Literal['json'] | None)

• engine (Literal['pandas', 'cudf'])

• run_label (str | None)

• validate (布尔值)

Return type:

Plottable

python_remote_json(code, api_token=None, dataset_id=None, engine='cudf', run_label=None, validate=True)

Parameters:

• self (Plottable)

• code (str)

• api_token (str | None)

• dataset_id (str | None)

• engine (Literal['pandas', 'cudf'])

• run_label (str | None)

• validate (bool)

Return type:

任何

python_remote_table(code, api_token=None, dataset_id=None, format='parquet', output_type='table', engine='cudf', run_label=None, validate=True)

Parameters:

• self (Plottable)

• code (str)

• api_token (str | None)

• dataset_id (str | None)

• format (Literal['json', 'csv', 'parquet'] | None)

• output_type (Literal['table', 'shape'] | None)

• engine (Literal['pandas', 'cudf'])

• run_label (str | None)

• validate (布尔值)

Return type:

数据框

scene_settings(menu=None, info=None, show_arrows=None, point_size=None, edge_curvature=None, edge_opacity=None, point_opacity=None)

Parameters:

• 菜单 (布尔 | 无)

• 信息 (布尔 | 无)

• show_arrows (bool | None)

• point_size (float | None)

• edge_curvature (float | None)

• edge_opacity (float | None)

• point_opacity (float | None)

Return type:

Plottable

server(v=None)

Parameters:

v (str | None)

Return type:

字符串

settings(height=None, url_params={}, render=None)

Parameters:

• height (float | None)

• url_params (Dict[str, Any])

• render (bool | Literal['auto'] | ~typing.Literal['g', 'url', 'ipython', 'databricks', 'browser'] | None)

Return type:

Plottable

to_cudf()

Return type:

Plottable

to_cugraph(directed=True, include_nodes=True, node_attributes=None, edge_attributes=None, kind='Graph')

Parameters:

• directed (bool)

• include_nodes (bool)

• node_attributes (列表[字符串] | 无)

• edge_attributes (列表[字符串] | 无)

• 类型 (字面量['Graph', 'MultiGraph', 'BiPartiteGraph'])

Return type:

任何

to_igraph(directed=True, use_vids=False, include_nodes=True, node_attributes=None, edge_attributes=None)

Parameters:

• directed (bool)

• use_vids (bool)

• include_nodes (bool)

• node_attributes (列表[字符串] | 无)

• edge_attributes (列表[字符串] | 无)

Return type:

任何

to_pandas()

Return type:

Plottable

upload(memoize=True, validate=True)

Parameters:

• memoize (布尔值)

• validate (布尔值)

Return type:

Plottable

PlotterBase 类

class graphistry.PlotterBase.PlotterBase(*args, **kwargs)

基础类：Plottable

图形绘制类。

使用 Graphistry.bind() 创建。

链式调用依次添加数据和视觉编码，并以绘图调用结束。

为了简化重用和可重放的笔记本，Plotter 操作是不可变的。每个链式调用都会返回一个从先前实例派生的新实例。然后可以使用旧的绘图器或新的绘图器来创建不同的图表。

在使用记忆化时，对于 .register(api=3) 会话与 .plot(memoize=True)，Pandas/cudf 的箭头强制转换会被记忆化，并且在相同哈希的数据帧上会跳过文件上传。

该类支持在Pandas、NetworkX和IGraph之间混合调用的便捷方法。

Parameters:

• args (任意)

• kwargs (任意)

DGL_graph: Any | None

addStyle(fg=None, bg=None, page=None, logo=None)

设置通用视觉样式

有关其他样式选项，请参阅 .bind() 和 .settings(url_params={})，以及 style() 作为设置相同属性的另一种方式。

为了便于重用和可重放的笔记本，addStyle() 调用是可链式调用的。调用不会影响旧样式：它反而会返回一个新的 Plotter 实例，新样式被添加到现有样式中。然后，旧样式和新样式都可以用于不同的图表。

addStyle() 将扩展现有的样式设置，而 style() 将替换同一组中的任何设置

Parameters:

• fg (dict) – 字典 {‘blendMode’: str}，包含任何有效的CSS混合模式

• bg (dict) – 页面背景属性的嵌套字典。{‘color’: str, ‘gradient’: {‘kind’: str, ‘position’: str, ‘stops’: list }, ‘image’: { ‘url’: str, ‘width’: int, ‘height’: int, ‘blendMode’: str }

• logo (dict) – 嵌套的logo属性字典。{ ‘url’: str, ‘autoInvert’: bool, ‘position’: str, ‘dimensions’: { ‘maxWidth’: int, ‘maxHeight’: int }, ‘crop’: { ‘top’: int, ‘left’: int, ‘bottom’: int, ‘right’: int }, ‘padding’: { ‘top’: int, ‘left’: int, ‘bottom’: int, ‘right’: int}, ‘style’: str}

• 页面 (字典) – 页面元数据设置的字典。{ ‘favicon’: str, ‘title’: str }

Returns:

绘图仪

Return type:

绘图仪

Example: Chained merge - results in color, blendMode, and url being set

g2 =  g.addStyle(bg={'color': 'black'}, fg={'blendMode': 'screen'})
g3 = g2.addStyle(bg={'image': {'url': 'http://site.com/watermark.png'}})

Example: Overwrite - results in blendMode multiply

g2 =  g.addStyle(fg={'blendMode': 'screen'})
g3 = g2.addStyle(fg={'blendMode': 'multiply'})

Example: Gradient background

g.addStyle(bg={'gradient': {'kind': 'linear', 'position': 45, 'stops': [['rgb(0,0,0)', '0%'], ['rgb(255,255,255)', '100%']]}})

Example: Page settings

g.addStyle(page={'title': 'Site - {{ name }}', 'favicon': 'http://site.com/logo.ico'})

base_url_client(v=None)

Parameters:

v (str | None)

Return type:

字符串

base_url_server(v=None)

Parameters:

v (str | None)

Return type:

字符串

bind(source=None, destination=None, node=None, edge=None, edge_title=None, edge_label=None, edge_color=None, edge_weight=None, edge_size=None, edge_opacity=None, edge_icon=None, edge_source_color=None, edge_destination_color=None, point_title=None, point_label=None, point_color=None, point_weight=None, point_size=None, point_opacity=None, point_icon=None, point_x=None, point_y=None, dataset_id=None, url=None, nodes_file_id=None, edges_file_id=None)

将数据属性与图形结构和视觉表示相关联。为了便于重用和可重放的笔记本，绑定调用是可链式调用的。调用不会影响旧的绑定：它反而会返回一个新的Plotter实例，新的绑定被添加到现有的绑定中。然后，旧的和新的绑定都可以用于不同的图形。

Parameters:

• source (可选[str]) – 包含边源ID的属性

• destination (可选[str]) – 包含边目标ID的属性

• node (可选[str]) – 包含节点ID的属性

• edge (可选[str]) – 包含边ID的属性

• edge_title (可选[str]) – 用于覆盖边的最小化标签文本的属性。默认情况下，使用边的源和目标。

• edge_label (可选[str]) – 属性覆盖边的扩展标签文本。默认情况下，显示可滚动的属性/值映射列表。

• edge_color (可选[str]) – 覆盖边颜色的属性。rgba (int64) 或 int32 调色板索引，有关值请参见 调色板 定义。基于 Color Brewer。

• edge_source_color (可选[str]) – 如果没有edge_color，则覆盖边的源颜色的属性，作为rgba int64值。

• edge_destination_color (可选[str]) – 如果没有edge_color，则覆盖边的目标颜色的属性，作为rgba int64值。

• edge_weight (Optional[str]) – 用于覆盖边权重的属性。默认值为1。高级布局控制将根据此值重新布局边。

• point_title (可选[str]) – 属性覆盖节点的最小化标签文本。默认情况下，使用节点ID。

• point_label (可选[str]) – 属性覆盖节点的扩展标签文本。默认情况下，显示属性/值映射的可滚动列表。

• point_color (可选[str]) –

  属性覆盖节点的颜色。rgba (int64) 或 int32 调色板索引，有关值请参阅 调色板 定义。基于 Color Brewer。

• point_size (可选[str]) – 属性覆盖节点的大小。默认情况下，使用节点的度数。可视化将标准化点的大小，并使用语义缩放动态调整。

• point_x (可选[str]) – 属性覆盖节点的初始x位置。与“.settings(url_params={‘play’: 0}))”结合使用以创建自定义布局

• point_y (可选[str]) – 属性覆盖节点的初始y位置。与“.settings(url_params={‘play’: 0}))”结合使用以创建自定义布局

• dataset_id (可选[str]) – 远程数据集ID

• url (可选[str]) – 远程数据集URL

• nodes_file_id (可选[str]) – 远程节点文件ID

• edges_file_id (可选[str]) – 远程边缘文件ID

• edge_size (str | None)

• edge_opacity (str | None)

• edge_icon (str | None)

• point_weight (str | None)

• point_opacity (str | None)

• point_icon (str | None)

Returns:

绘图仪

Return type:

绘图仪

示例：最小化

import graphistry
g = graphistry.bind()
g = g.bind(source='src', destination='dst')

示例：节点颜色

import graphistry
g = graphistry.bind()
g = g.bind(source='src', destination='dst',
           node='id', point_color='color')

示例：链式调用

import graphistry
g = graphistry.bind(source='src', destination='dst', node='id')

g1 = g.bind(point_color='color1', point_size='size1')

g.bind(point_color='color1b')

g2a = g1.bind(point_color='color2a')
g2b = g1.bind(point_color='color2b', point_size='size2b')

g3a = g2a.bind(point_size='size3a')
g3b = g2b.bind(point_size='size3b')

在上面的链式示例中，所有绑定都使用 src/dst/id。颜色和大小绑定到：

g: default/default
g1: color1/size1
g2a: color2a/size1
g2b: color2b/size2b
g3a: color2a/size3a
g3b: color2b/size3b

bolt(driver)

chain(ops)

ops 是 Union[List[ASTObject], Chain]

Parameters:

ops (任意类型 | 列表[任意类型])

Return type:

Plottable

chain_remote(chain, api_token=None, dataset_id=None, output_type='all', format=None, df_export_args=None, node_col_subset=None, edge_col_subset=None, engine=None)

chain 是 Union[List[ASTObject], Chain]

Parameters:

• self (Plottable)

• chain (Any | Dict[str, None | bool | str | float | int | List[None | bool | str | float | int | List[JSONVal] | Dict[str, JSONVal]] | Dict[str, None | bool | str | float | int | List[JSONVal] | Dict[str, JSONVal]]])

• api_token (str | None)

• dataset_id (str | None)

• output_type (Literal['all', 'nodes', 'edges', 'shape'])

• format (Literal['json', 'csv', 'parquet'] | None)

• df_export_args (Dict[str, Any] | None)

• node_col_subset (List[str] | None)

• edge_col_subset (List[str] | None)

• engine (Literal['pandas', 'cudf'] | None)

Return type:

Plottable

chain_remote_shape(chain, api_token=None, dataset_id=None, format=None, df_export_args=None, node_col_subset=None, edge_col_subset=None, engine=None)

chain 是 Union[List[ASTObject], Chain]

Parameters:

• self (Plottable)

• chain (Any | Dict[str, None | bool | str | float | int | List[None | bool | str | float | int | List[JSONVal] | Dict[str, JSONVal]] | Dict[str, None | bool | str | float | int | List[JSONVal] | Dict[str, JSONVal]]])

• api_token (str | None)

• dataset_id (str | None)

• format (Literal['json', 'csv', 'parquet'] | None)

• df_export_args (Dict[str, Any] | None)

• node_col_subset (List[str] | None)

• edge_col_subset (List[str] | None)

• engine (Literal['pandas', 'cudf'] | None)

Return type:

数据框

client_protocol_hostname(v=None)

获取或设置客户端协议和主机名，例如，“https://hub.graphistry.com”。

默认情况下，使用 {protocol()}://{server()}。通常在公共浏览器路由与后端服务器路由不同时使用，例如，企业WAF路由用于浏览器，内部防火墙路由用于服务器。

请注意，集合是作为PyGraphistry._config条目的全局变量，因此在多用户环境中要小心。

Parameters:

v (str | None)

Return type:

字符串

collapse(node, attribute, column, self_edges=False, unwrap=False, verbose=False)

Parameters:

• 节点 (字符串 | 整数)

• 属性 (字符串 | 整数)

• 列 (字符串 | 整数)

• self_edges (bool)

• unwrap (bool)

• verbose (bool)

Return type:

Plottable

compute_cugraph(alg, out_col=None, params={}, kind='Graph', directed=True, G=None)

在图上运行cugraph算法。有关算法参数，请参阅cuGraph文档。

Parameters:

• alg (str) – 算法名称

• out_col (可选[str]) – 节点表输出列名，默认为 alg 参数

• params (dict) – 传递给cuGraph的算法参数，作为kwargs

• kind (CuGraphKind) – 使用的cugraph类型

• directed (bool) – 图是否为有向图

• G (可选[cugraph.Graph]) – 使用的cugraph图；如果为None，则使用self

Returns:

Plottable

Return type:

Plottable

Example: Pass params to cugraph

edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['c','c','e','e']})
g = graphistry.edges(edges, 's', 'd')
g2 = g.compute_cugraph('betweenness_centrality', params={'k': 2})
assert 'betweenness_centrality' in g2._nodes.columns

Example: Pagerank

edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['c','c','e','e']})
g = graphistry.edges(edges, 's', 'd')
g2 = g.compute_cugraph('pagerank')
assert 'pagerank' in g2._nodes.columns

Example: Personalized Pagerank

::

edges = pd.DataFrame({‘s’: [‘a’,’b’,’c’,’d’], ‘d’: [‘c’,’c’,’e’,’e’]}) g = graphistry.edges(edges, ‘s’, ‘d’) g2 = g.compute_cugraph(‘pagerank’, params={‘personalization’: cudf.DataFrame({‘vertex’: [‘a’], ‘values’: [1]})}) assert ‘pagerank’ in g2._nodes.columns

Example: Katz centrality with rename

edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['c','c','e','e']})
g = graphistry.edges(edges, 's', 'd')
g2 = g.compute_cugraph('katz_centrality', out_col='katz_centrality_renamed')
assert 'katz_centrality_renamed' in g2._nodes.columns

compute_igraph(alg, out_col=None, directed=None, use_vids=False, params={}, stringify_rich_types=True)

使用igraph方法丰富或替换图形

Parameters:

• alg (str) – igraph.Graph方法的名称，例如pagerank

• out_col (可选[str]) – 对于生成节点属性列的算法，out_col 是期望的输出列名。当为 None 时，使用算法的名称。（默认值为 None）

• directed (可选[布尔值]) – 在转换为igraph时，是否是有向的。如果为None，则尝试有向和无向。(默认值为None)

• use_vids (bool) – 在转换为igraph时，是否将ID解释为igraph顶点ID（非负整数）或任意值（False，默认值）

• params (dict) – 传递给底层igraph方法的任何命名参数

• stringify_rich_types (bool) – 当返回像igraph.Graph这样的丰富类型时，可能会对下游渲染造成问题，将它们强制转换为字符串

Returns:

绘图仪

Return type:

绘图仪

Example: Pagerank

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['c','c','e','e']})
g = graphistry.edges(edges, 's', 'd').materialize_nodes()
g2 = g.compute_igraph('pagerank')
assert 'pagerank' in g2._nodes.columns

Example: Pagerank with custom name

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['c','c','e','e']})
g = graphistry.edges(edges, 's', 'd').materialize_nodes()
g2 = g.compute_igraph('pagerank', out_col='my_pr')
assert 'my_pr' in g2._nodes.columns

Example: Pagerank on an undirected

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['c','c','e','e']})
g = graphistry.edges(edges, 's', 'd').materialize_nodes()
g2 = g.compute_igraph('pagerank', directed=False)
assert 'pagerank' in g2._nodes.columns

Example: Pagerank with custom parameters

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['c','c','e','e']})
g = graphistry.edges(edges, 's', 'd').materialize_nodes()
g2 = g.compute_igraph('pagerank', params={'damping': 0.85})
assert 'pagerank' in g2._nodes.columns

Example: Personalized Pagerank

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['c','c','e','e']})
g = graphistry.edges(edges, 's', 'd').materialize_nodes()
g2 = g.compute_igraph('personalized_pagerank')
assert 'personalized_pagerank' in g2._nodes.columns

copy()

Return type:

Plottable

cypher(query, params={})

对Neo4j、Memgraph或Amazon Neptune数据库执行Cypher查询并检索结果。

此方法使用BOLT驱动程序在Neo4j、Memgraph或Amazon Neptune图数据库上运行Cypher查询。 查询结果被转换为节点和边的DataFrame，然后绑定到当前的图可视化上下文。您还可以通过params参数向Cypher查询传递参数。

Parameters:

• query (str) – 要执行的Cypher查询字符串。

• params (dict, optional) – 可选的参数字典，用于传递给Cypher查询。

Returns:

基于查询结果更新节点和边的绘图器。

Return type:

PlotterBase

Raises:

ValueError – 如果没有可用的BOLT驱动程序连接。

示例（简单的Neo4j查询）

import graphistry
from neo4j import GraphDatabase

# Register with Neo4j connection details
uri = "bolt://localhost:7687"
driver = GraphDatabase.driver(uri, auth=("neo4j", "password"))

graphistry.register(bolt=driver)

# Run a basic Cypher query
g = graphistry.cypher('''
    MATCH (node1)-[connection]-(node2)
    RETURN node1, connection, node2;
''')

# Visualize the results
g.plot()

示例（简单的Amazon Neptune查询）

from neo4j import GraphDatabase

# Register with Amazon Neptune connection details
uri = f"bolt://{url}:8182"
driver = GraphDatabase.driver(uri, auth=("ignored", "ignored"), encrypted=True)

graphistry.register(bolt=driver)

# Run a simple Cypher query
g = graphistry.cypher('''
    MATCH (node1)-[connection]-(node2)
    RETURN node1, connection, node2;
''')

# Visualize the results
g.plot()

示例（简单的Memgraph查询）

import graphistry
from neo4j import GraphDatabase

# Register with Memgraph connection details
MEMGRAPH = {
    'uri': "bolt://localhost:7687", 
    'auth': (" ", " ")
}

graphistry.register(api=3, username="X", password="Y", bolt=MEMGRAPH)

# Run a simple Cypher query on Memgraph
g = graphistry.cypher('''
    MATCH (node1)-[connection]-(node2)
    RETURN node1, connection, node2;
''')

# Visualize the results
g.plot()

示例（带有节点和边检查的参数化查询）

import graphistry
from neo4j import GraphDatabase

# Register with Neo4j connection details
uri = "bolt://localhost:7687"
driver = GraphDatabase.driver(uri, auth=("neo4j", "password"))

graphistry.register(bolt=driver)

# Run a parameterized Cypher query
query = '''
    MATCH (node1)-[connection]-(node2)
    WHERE node1.name = $name
    RETURN node1, connection, node2;
'''
params = {"name": "Alice"}

g = graphistry.cypher(query, params)

# Inspect the resulting nodes and edges DataFrames
print(g._nodes)  # DataFrame with node information
print(g._edges)  # DataFrame with edge information

# Visualize the results
g.plot()

这演示了如何连接到Neo4j、Memgraph或Amazon Neptune，运行简单或参数化的Cypher查询，检查查询结果（节点和边），并可视化图形。

description(description)

上传描述

Parameters:

描述 (str) – 上传描述

drop_nodes(nodes)

Parameters:

节点 (任意)

Return type:

Plottable

edges(edges, source=None, destination=None, edge=None, *args, **kwargs)

指定边列表数据和相关的边属性值。 如果是可调用的，将使用当前的绘图器和任何位置+命名参数进行调用。

Parameters:

• edges (Pandas dataframe, NetworkX graph, 或 IGraph graph) – 边及其属性，或从Plotter转换为边

• self (Plottable)

Returns:

绘图仪

Return type:

绘图仪

Example

import graphistry
df = pandas.DataFrame({'src': [0,1,2], 'dst': [1,2,0]})
graphistry
    .bind(source='src', destination='dst')
    .edges(df)
    .plot()

Example

import graphistry
df = pandas.DataFrame({'src': [0,1,2], 'dst': [1,2,0], 'id': [0, 1, 2]})
graphistry
    .bind(source='src', destination='dst', edge='id')
    .edges(df)
    .plot()

Example

import graphistry
df = pandas.DataFrame({'src': [0,1,2], 'dst': [1,2,0]})
graphistry
    .edges(df, 'src', 'dst')
    .plot()

Example

import graphistry
df = pandas.DataFrame({'src': [0,1,2], 'dst': [1,2,0], 'id': [0, 1, 2]})
graphistry
    .edges(df, 'src', 'dst', 'id')
    .plot()

Example

import graphistry

def sample_edges(g, n):
    return g._edges.sample(n)

df = pandas.DataFrame({'src': [0,1,2], 'dst': [1,2,0]})

graphistry
    .edges(df, 'src', 'dst')
    .edges(sample_edges, n=2)
    .edges(sample_edges, None, None, None, 2)  # equivalent
    .plot()

encode_axis(rows=[])

渲染径向和线性轴，带有可选的标签

Parameters:

rows (List[Dict]) – 行列表 - { label: Optional[str],?r: float, ?x: float, ?y: float, ?internal: true, ?external: true, ?space: true }

Returns:

绘图仪

Return type:

绘图仪

Example: Several radial axes

g.encode_axis([
  {'r': 14, 'external': True, 'label': 'outermost'},
  {'r': 12, 'external': True},
  {'r': 10, 'space': True},
  {'r': 8, 'space': True},
  {'r': 6, 'internal': True},
  {'r': 4, 'space': True},
  {'r': 2, 'space': True, 'label': 'innermost'}
])

Example: Several horizontal axes

g.encode_axis([
  {"label": "a",  "y": 2, "internal": True },
  {"label": "b",  "y": 40, "external": True, "width": 20, "bounds": {"min": 40, "max": 400}},
])

encode_edge_badge(column, position='TopRight', categorical_mapping=None, continuous_binning=None, default_mapping=None, comparator=None, color=None, bg=None, fg=None, for_current=False, for_default=True, as_text=None, blend_mode=None, style=None, border=None, shape=None)

encode_edge_color(column, palette=None, as_categorical=None, as_continuous=None, categorical_mapping=None, default_mapping=None, for_default=True, for_current=False)

设置边缘颜色，比bind()有更多控制

Parameters:

• column (str) – 数据列名称

• palette (可选[列表]) – 可选的类似颜色的字符串列表。例如：[“black, “#FF0”, “rgb(255,255,255)” ]。用于连续和轮询分类的渐变。

• as_categorical (可选[布尔值]) – 将列值解释为分类值。例如：当值多于调色板条目时，通过轮询使用调色板。

• as_continuous (可选[布尔值]) – 将列值解释为连续的。例如：当值多于调色板条目时，使用调色板进行插值渐变。

• categorical_mapping (可选[字典]) – 从列值到颜色类字符串的映射。例如：{“car”: “red”, “truck”: #000”}

• default_mapping (可选[str]) – 使用不在categorical_mapping中的值的映射来增强categorical_mapping。例如：default_mapping=”gray”。

• for_default (可选[bool]) – 当没有用户覆盖设置时使用编码。默认开启。

• for_current (可选[bool]) – 使用当前活动的编码。清除活动编码会将其重置为默认值，可能有所不同。默认开启。

Returns:

绘图仪

Return type:

绘图仪

示例：参见 encode_point_color

encode_edge_icon(column, categorical_mapping=None, continuous_binning=None, default_mapping=None, comparator=None, for_default=True, for_current=False, as_text=False, blend_mode=None, style=None, border=None, shape=None)

设置边缘图标，比bind()有更多的控制。来自Font Awesome 4的值，如“laptop”：https://fontawesome.com/v4.7.0/icons/，图片URL（http://…），以及数据URI（data:…）。当启用as_text=True时，值将被解释为原始字符串。

Parameters:

• column (str) – 数据列名称

• categorical_mapping (可选[字典]) – 从列值到图标名称字符串的映射。例如：{“toyota”: ‘car’, “ford”: ‘truck’}

• default_mapping (可选[联合[整数,浮点数]]) – 使用不在categorical_mapping中的值的映射来增强categorical_mapping。例如：default_mapping=50。

• for_default (可选[bool]) – 当没有用户覆盖设置时使用编码。默认开启。

• for_current (可选[bool]) – 使用当前活动的编码。清除活动编码会将其重置为默认值，这可能有所不同。默认开启。

• as_text (可选[布尔值]) – 值应被视为原始字符串，而不是图标和图像。（默认值为 False。）

Returns:

绘图仪

Return type:

绘图仪

Example: Set a string column of icons for the edge icons, same as bind(edge_icon=’my_column’)

g2a = g.encode_edge_icon('my_icons_column')

Example: Map specific values to specific icons, including with a default

g2a = g.encode_edge_icon('brands', categorical_mapping={'toyota': 'car', 'ford': 'truck'})
g2b = g.encode_edge_icon('brands', categorical_mapping={'toyota': 'car', 'ford': 'truck'}, default_mapping='question')

Example: Map countries to abbreviations

g2a = g.encode_edge_icon('country_abbrev', as_text=True)
g2b = g.encode_edge_icon('country', as_text=True, categorical_mapping={'England': 'UK', 'America': 'US'}, default_mapping='')

Example: Border

g2b = g.encode_edge_icon('country', border={'width': 3, color: 'black', 'stroke': 'dashed'}, 'categorical_mapping={'England': 'UK', 'America': 'US'})

encode_point_badge(column, position='TopRight', categorical_mapping=None, continuous_binning=None, default_mapping=None, comparator=None, color=None, bg=None, fg=None, for_current=False, for_default=True, as_text=None, blend_mode=None, style=None, border=None, shape=None)

encode_point_color(column, palette=None, as_categorical=None, as_continuous=None, categorical_mapping=None, default_mapping=None, for_default=True, for_current=False)

设置点颜色，比bind()有更多的控制

Parameters:

• column (str) – 数据列名称

• palette (可选[列表]) – 可选的类似颜色的字符串列表。例如：[“black, “#FF0”, “rgb(255,255,255)” ]。用于连续和轮询分类的渐变。

• as_categorical (可选[布尔值]) – 将列值解释为分类值。例如：当值多于调色板条目时，通过轮询使用调色板。

• as_continuous (可选[布尔值]) – 将列值解释为连续的。例如：当值多于调色板条目时，使用调色板进行插值渐变。

• categorical_mapping (可选[字典]) – 从列值到颜色类字符串的映射。例如：{“car”: “red”, “truck”: #000”}

• default_mapping (可选[str]) – 使用不在categorical_mapping中的值的映射来增强categorical_mapping。例如：default_mapping=”gray”。

• for_default (可选[bool]) – 当没有用户覆盖设置时使用编码。默认开启。

• for_current (可选[bool]) – 使用当前活动的编码。清除活动编码会将其重置为默认值，可能有所不同。默认开启。

Returns:

绘图仪

Return type:

绘图仪

Example: Set a palette-valued column for the color, same as bind(point_color=’my_column’)

g2a = g.encode_point_color('my_int32_palette_column')
g2b = g.encode_point_color('my_int64_rgb_column')

Example: Set a cold-to-hot gradient of along the spectrum blue, yellow, red

g2 = g.encode_point_color('my_numeric_col', palette=["blue", "yellow", "red"], as_continuous=True)

Example: Round-robin sample from 5 colors in hex format

g2 = g.encode_point_color('my_distinctly_valued_col', palette=["#000", "#00F", "#0F0", "#0FF", "#FFF"], as_categorical=True)

Example: Map specific values to specific colors, including with a default

g2a = g.encode_point_color('brands', categorical_mapping={'toyota': 'red', 'ford': 'blue'})
g2a = g.encode_point_color('brands', categorical_mapping={'toyota': 'red', 'ford': 'blue'}, default_mapping='gray')

encode_point_icon(column, categorical_mapping=None, continuous_binning=None, default_mapping=None, comparator=None, for_default=True, for_current=False, as_text=False, blend_mode=None, style=None, border=None, shape=None)

设置节点图标，比bind()有更多的控制。可以使用Font Awesome 4中的值，如“laptop”：https://fontawesome.com/v4.7.0/icons/，图像URL（http://…），以及数据URI（data:…）。当启用as_text=True时，值将被解释为原始字符串。

Parameters:

• column (str) – 数据列名称

• categorical_mapping (可选[字典]) – 从列值到图标名称字符串的映射。例如：{“toyota”: ‘car’, “ford”: ‘truck’}

• default_mapping (可选[联合[整数,浮点数]]) – 使用不在categorical_mapping中的值的映射来增强categorical_mapping。例如：default_mapping=50。

• for_default (可选[bool]) – 当没有用户覆盖设置时使用编码。默认开启。

• for_current (可选[bool]) – 使用当前活动的编码。清除活动编码会将其重置为默认值，可能有所不同。默认开启。

• as_text (Optional[bool]) – 值应被视为原始字符串，而不是图标和图像。（默认值为 False。）

• blend_mode (可选[str]) – CSS 混合模式

• style (可选[字典]) – CSS 滤镜属性 - 不透明度、饱和度、亮度、灰度等

• border (可选[字典]) – 边框属性 - ‘宽度’, ‘颜色’, 和 ‘线条’

Returns:

绘图仪

Return type:

绘图仪

Example: Set a string column of icons for the point icons, same as bind(point_icon=’my_column’)

g2a = g.encode_point_icon('my_icons_column')

Example: Map specific values to specific icons, including with a default

g2a = g.encode_point_icon('brands', categorical_mapping={'toyota': 'car', 'ford': 'truck'})
g2b = g.encode_point_icon('brands', categorical_mapping={'toyota': 'car', 'ford': 'truck'}, default_mapping='question')

Example: Map countries to abbreviations

g2b = g.encode_point_icon('country_abbrev', as_text=True)
g2b = g.encode_point_icon('country', as_text=True, categorical_mapping={'England': 'UK', 'America': 'US'}, default_mapping='')

Example: Border

g2b = g.encode_point_icon('country', border={'width': 3, color: 'black', 'stroke': 'dashed'}, 'categorical_mapping={'England': 'UK', 'America': 'US'})

encode_point_size(column, categorical_mapping=None, default_mapping=None, for_default=True, for_current=False)

设置点大小，比bind()有更多的控制

Parameters:

• column (str) – 数据列名称

• categorical_mapping (可选[字典]) – 从列值到数字的映射。例如：{“car”: 100, “truck”: 200}

• default_mapping (可选[联合[整数,浮点数]]) – 使用不在categorical_mapping中的值的映射来增强categorical_mapping。例如：default_mapping=50。

• for_default (可选[bool]) – 当没有用户覆盖设置时使用编码。默认开启。

• for_current (可选[bool]) – 使用当前活动的编码。清除活动编码会将其重置为默认值，这可能有所不同。默认开启。

Returns:

绘图仪

Return type:

绘图仪

Example: Set a numerically-valued column for the size, same as bind(point_size=’my_column’)

g2a = g.encode_point_size('my_numeric_column')

Example: Map specific values to specific colors, including with a default

g2a = g.encode_point_size('brands', categorical_mapping={'toyota': 100, 'ford': 200})
g2b = g.encode_point_size('brands', categorical_mapping={'toyota': 100, 'ford': 200}, default_mapping=50)

fa2_layout(fa2_params=None, circle_layout_params=None, singleton_layout=None, partition_key=None, engine=EngineAbstract.AUTO)

Parameters:

• fa2_params (Dict[str, Any] | None)

• circle_layout_params (Dict[str, Any] | None)

• singleton_layout (可调用[[Plottable, 元组[float, float, float, float] | 任意], Plottable] | 无)

• partition_key (str | None)

• engine (EngineAbstract | str)

Return type:

Plottable

filter_edges_by_dict(filter_dict=None)

Parameters:

filter_dict (字典 | 无)

Return type:

Plottable

filter_nodes_by_dict(filter_dict=None)

Parameters:

filter_dict (字典 | 无)

Return type:

Plottable

from_cugraph(G, node_attributes=None, edge_attributes=None, load_nodes=True, load_edges=True, merge_if_existing=True)

如果绑定了ID，请在返回的图中使用相同的ID。

如果节点/边非空，则使用现有拓扑并合并G的属性，而不是返回G的拓扑

Parameters:

• node_attributes (列表[字符串] | 无)

• edge_attributes (列表[字符串] | 无)

• load_nodes (bool)

• load_edges (bool)

• merge_if_existing (bool)

from_igraph(ig, node_attributes=None, edge_attributes=None, load_nodes=True, load_edges=True, merge_if_existing=True)

将igraph对象转换为Plotter

如果基础 g 有 _node、_source、_destination 定义，请使用它们

当 merge_if_existing 与预先存在的节点/边 df 和形状匹配 ig 时，合并属性

为了使merge_if_existing能够处理边，必须设置g._edge并在igraph.Graph中具有相应的边索引属性。

Parameters:

• ig (igraph) – 源 igraph 对象

• node_attributes (可选[列表[字符串]]) – 要加载的节点属性子集；None 表示加载所有属性（默认）

• edge_attributes (可选[列表[字符串]]) – 要加载的边属性子集；None 表示全部（默认）

• load_nodes (bool) – 是否加载节点数据框（默认为 True）

• load_edges (bool) – 是否加载边的数据框（默认为 True）

• merge_if_existing – 是否与现有的节点/边数据框合并（默认为 True）

• merge_if_existing – bool

Returns:

绘图仪

Example: Convert from igraph, including all node/edge properties

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a', 'b', 'c', 'd'], 'd': ['b', 'c', 'd', 'e'], 'v': [101, 102, 103, 104]})
g = graphistry.edges(edges, 's', 'd').materialize_nodes().get_degrees()
assert 'degree' in g._nodes.columns
g2 = g.from_igraph(g.to_igraph())
assert len(g2._nodes.columns) == len(g._nodes.columns)

Example: Enrich from igraph, but only load in 1 node attribute

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a', 'b', 'c', 'd'], 'd': ['b', 'c', 'd', 'e'], 'v': [101, 102, 103, 104]})
g = graphistry.edges(edges, 's', 'd').materialize_nodes().get_degree()
assert 'degree' in g._nodes
ig = g.to_igraph(include_nodes=False)
assert 'degree' not in ig.vs
ig.vs['pagerank'] = ig.pagerank()
g2 = g.from_igraph(ig, load_edges=False, node_attributes=[g._node, 'pagerank'])
assert 'pagerank' in g2._nodes
asssert 'degree' in g2._nodes

from_networkx(G)

将NetworkX图转换为PyGraphistry图。

此方法接受一个NetworkX图并将其转换为PyGraphistry可用于可视化的格式。它从NetworkX图中提取节点和边数据，并将它们绑定到图对象上，以便使用PyGraphistry的API进行进一步操作或可视化。

Parameters:

G (networkx.Graph 或 networkx.DiGraph) – 要转换的NetworkX图。

Returns:

一个PyGraphistry可绘制对象，包含来自NetworkX图的节点和边数据。

Return type:

Plottable

Example: Basic NetworkX Conversion

import graphistry
import networkx as nx

# Create a NetworkX graph
G = nx.Graph()
G.add_nodes_from([
    (1, {"v": "one"}), 
    (2, {"v": "two"}), 
    (3, {"v": "three"}), 
    (4, {"v": "four"}), 
    (7, {"v": "seven"}), 
    (8, {"v": "eight"})
])
G.add_edges_from([
    [2, 3], 
    [3, 4], 
    [7, 8]
])

# Convert the NetworkX graph to PyGraphistry format
g = from_networkx(G)

g.plot()

此示例创建了一个包含节点和边的简单NetworkX图，使用from_networkx()进行转换，然后使用PyGraphistry API进行绘制。

Example: Using Custom Node and Edge Bindings

import graphistry
import networkx as nx

# Create a NetworkX graph with attributes
G = nx.Graph()
G.add_nodes_from([
    (1, {"v": "one"}), 
    (2, {"v": "two"}), 
    (3, {"v": "three"}), 
    (4, {"v": "four"}), 
    (7, {"v": "seven"}), 
    (8, {"v": "eight"})
])
G.add_edges_from([
    [2, 3], 
    [3, 4], 
    [7, 8]
])

# Bind custom node and edge names when converting from NetworkX to PyGraphistry
g = graphistry.bind(source='src', destination='dst').from_networkx(G)

g.plot()

get_degrees(col='degree', degree_in='degree_in', degree_out='degree_out')

Parameters:

• col (str)

• degree_in (str)

• degree_out (str)

Return type:

Plottable

get_indegrees(col='degree_in')

Parameters:

col (str)

Return type:

Plottable

get_outdegrees(col='degree_out')

Parameters:

col (str)

Return type:

Plottable

get_topological_levels(level_col='level', allow_cycles=True, warn_cycles=True, remove_self_loops=True)

Parameters:

• level_col (str)

• allow_cycles (bool)

• warn_cycles (bool)

• remove_self_loops (bool)

Return type:

Plottable

graph(ig)

指定节点和边的数据。

Parameters:

ig (Any) – 具有节点和边属性的NetworkX图或IGraph图。

Returns:

绘图仪

Return type:

绘图仪

gsql(query, bindings={}, dry_run=False)

在解释模式下运行Tigergraph查询并返回转换后的Plottable

param query:

要运行的代码

type query:

字符串

param bindings:

映射定义返回的‘edges’和/或‘nodes’的名称，默认为@@nodeList和@@edgeList

type bindings:

可选[字典]

param dry_run:

返回目标URL而不运行

type dry_run:

布尔

returns:

绘图仪

rtype:

绘图仪

Example: Minimal

import graphistry
tg = graphistry.tigergraph()
tg.gsql("""
INTERPRET QUERY () FOR GRAPH Storage { 

    OrAccum<BOOL> @@stop;
    ListAccum<EDGE> @@edgeList;
    SetAccum<vertex> @@set;

    @@set += to_vertex("61921", "Pool");

    Start = @@set;

    while Start.size() > 0 and @@stop == false do

    Start = select t from Start:s-(:e)-:t
    where e.goUpper == TRUE
    accum @@edgeList += e
    having t.type != "Service";
    end;

    print @@edgeList;
}
""").plot()

Example: Full

import graphistry
tg = graphistry.tigergraph()
tg.gsql("""
INTERPRET QUERY () FOR GRAPH Storage { 

    OrAccum<BOOL> @@stop;
    ListAccum<EDGE> @@edgeList;
    SetAccum<vertex> @@set;

    @@set += to_vertex("61921", "Pool");

    Start = @@set;

    while Start.size() > 0 and @@stop == false do

    Start = select t from Start:s-(:e)-:t
    where e.goUpper == TRUE
    accum @@edgeList += e
    having t.type != "Service";
    end;

    print @@my_edge_list;
}
""", {'edges': 'my_edge_list'}).plot()

gsql_endpoint(method_name, args={}, bindings={}, db=None, dry_run=False)

在用户定义的端点调用Tigergraph存储过程并返回转换后的Plottable

Parameters:

• method_name (str) – 存储过程名称

• args (可选[字典]) – 命名的端点参数

• bindings (可选[字典]) – 定义返回的‘edges’和/或‘nodes’名称的映射，默认为@@nodeList和@@edgeList

• db (可选[str]) – 数据库的名称，默认为 .tigergraph(…) 中设置的值

• dry_run (bool) – 返回目标URL而不运行

Returns:

绘图仪

Return type:

绘图仪

Example: Minimal

import graphistry
tg = graphistry.tigergraph(db='my_db')
tg.gsql_endpoint('neighbors').plot()

Example: Full

import graphistry
tg = graphistry.tigergraph()
tg.gsql_endpoint('neighbors', {'k': 2}, {'edges': 'my_edge_list'}, 'my_db').plot()

Example: Read data

import graphistry
tg = graphistry.tigergraph()
out = tg.gsql_endpoint('neighbors')
(nodes_df, edges_df) = (out._nodes, out._edges)

hop(nodes, hops=1, to_fixed_point=False, direction='forward', edge_match=None, source_node_match=None, destination_node_match=None, source_node_query=None, destination_node_query=None, edge_query=None, return_as_wave_front=False, target_wave_front=None)

Parameters:

• 节点 (数据框 | 无)

• hops (int | None)

• to_fixed_point (bool)

• 方向 (str)

• edge_match (dict | None)

• source_node_match (dict | None)

• destination_node_match (dict | None)

• source_node_query (str | None)

• destination_node_query (str | None)

• edge_query (str | None)

• return_as_wave_front (bool)

• target_wave_front (DataFrame | None)

Return type:

Plottable

hypergraph(raw_events, entity_types=None, opts={}, drop_na=True, drop_edge_attrs=False, verbose=True, direct=False, engine='pandas', npartitions=None, chunksize=None)

将数据框转换为超图。

Parameters:

• raw_events (pandas.DataFrame) – 要转换的数据框（pandas 或 cudf）。

• entity_types (可选[列表]) – 要转换为节点的列（字符串），None 表示所有

• opts (dict) – 请参见下文

• drop_edge_attrs (bool) – 是否在边上包含每行的属性，默认为 False（包含）

• verbose (bool) – 是否打印大小信息

• direct (bool) – 省略超节点，而是在事件中强连接节点

• engine (bool) – 用于指定引擎的字符串（pandas, cudf, …）

• npartitions (可选[int]) – 对于分布式引擎，将事件分成多少粗粒度的部分

• chunksize (可选[int]) – 对于分布式引擎，在chunksize行后分割事件

• drop_na (布尔值)

从数据框中创建图形，并将图形组件作为数据框返回，以及可渲染的结果Plotter。超图揭示了行之间和列值之间的关系。此转换对于事件列表、样本、关系和其他结构化高维数据非常有用。

通过传递engine=’pandas’、‘cudf’、‘dask’、‘dask_cudf’（默认：‘pandas’）来指定本地计算引擎。 如果事件不是该引擎的格式，它们将被转换为该格式。

转换会为entity_types列中的每个唯一值创建一个节点（默认：所有列）。 如果direct=False（默认），每一行也会被转换为一个节点。 添加边以连接每个表格单元格到其原始行的节点，或者如果direct=True，则连接到同一行的其他节点。 节点被赋予与原始列名对应的'type'属性，或者在行的情况下，赋予'EventID'属性。 选项进一步控制转换，例如列类别定义，用于控制不同列中重复出现的值是否应被视为一个节点， 或者是否仅在特定列类型对之间绘制边。

考虑一个事件列表。每一行代表一个独特的事件，每一列代表事件的某些元数据。如果多个事件有共同的元数据，它们将通过这些元数据值进行传递连接。布局算法将尝试将事件聚集在一起。相反，如果一个事件有独特的元数据，独特的元数据将变成只与事件节点连接的节点，聚类算法将使它们围绕事件节点形成一个环。

最佳实践是将EVENTID设置为行的唯一ID， 将SKIP设置为所有非分类列（或将entity_types设置为所有分类列）， 并将CATEGORY设置为具有相同类型值的列组。

为了防止为null值创建节点，设置drop_na=True。 一些数据框引擎可能具有不理想的null处理方式， 并建议用np.nan替换None值。

可选的 opts={...} 配置选项包括：

• ‘EVENTID’: 用于检查行ID的列名。默认情况下，使用行索引。

• ‘CATEGORIES’: 字典将类别名称映射到包含的列。例如，{‘IP’: [‘srcAddress’, ‘dstAddress’]}。如果相同的IP出现在两列中，这将使转换为其生成一个节点，而不是为每列生成一个节点。

• ‘DELIM’: 在创建节点ID时，定义列名和节点值之间使用的分隔符

• ‘SKIP’: 不转换为节点的列名列表。例如，日期和数字通常会被跳过。

• ‘EDGES’：对于direct=True，不是创建所有边，而是选择列对。例如，{‘a’: [‘b’, ‘d’], ‘d’: [‘d’]} 创建列 a->b 和 a->d 之间的边，以及自边 d->d。

Returns:

{'实体': DF, '事件': DF, '边': DF, '节点': DF, '图': Plotter}

Return type:

字典

Parameters:

• entity_types (列表[字符串] | 无)

• opts (dict)

• drop_na (布尔值)

• drop_edge_attrs (bool)

• verbose (bool)

• direct (bool)

• engine (str)

• npartitions (int | None)

• chunksize (int | None)

示例：连接用户<-行->老板

import graphistry
users_df = pd.DataFrame({'user': ['a','b','x'], 'boss': ['x', 'x', 'y']})
h = graphistry.hypergraph(users_df)
g = h['graph'].plot()

示例：连接用户->老板

import graphistry
users_df = pd.DataFrame({'user': ['a','b','x'], 'boss': ['x', 'x', 'y']})
h = graphistry.hypergraph(users_df, direct=True)
g = h['graph'].plot()

示例：连接用户<->老板

import graphistry
users_df = pd.DataFrame({'user': ['a','b','x'], 'boss': ['x', 'x', 'y']})
h = graphistry.hypergraph(users_df, direct=True, opts={'EDGES': {'user': ['boss'], 'boss': ['user']}})
g = h['graph'].plot()

示例：仅考虑节点的某些列

import graphistry
users_df = pd.DataFrame({'user': ['a','b','x'], 'boss': ['x', 'x', 'y']})
h = graphistry.hypergraph(users_df, entity_types=['boss'])
g = h['graph'].plot()

示例：将匹配的 user:: 和 boss:: 节点折叠为一个人:: 节点

import graphistry
users_df = pd.DataFrame({'user': ['a','b','x'], 'boss': ['x', 'x', 'y']})
h = graphistry.hypergraph(users_df, opts={'CATEGORIES': {'person': ['user', 'boss']}})
g = h['graph'].plot()

示例：使用 cudf 引擎代替 pandas

import cudf, graphistry
users_gdf = cudf.DataFrame({'user': ['a','b','x'], 'boss': ['x', 'x', 'y']})
h = graphistry.hypergraph(users_gdf, engine='cudf')
g = h['graph'].plot()

igraph2pandas(ig)

在当前绑定下，将IGraph转换为pandas的边数据框和节点数据框。

已弃用，推荐使用 .from_igraph()

Example

import graphistry
g = graphistry.bind()

es = pandas.DataFrame({'src': [0,1,2], 'dst': [1,2,0]})
g = g.bind(source='src', destination='dst').edges(es)

ig = g.pandas2igraph(es)
ig.vs['community'] = ig.community_infomap().membership

(es2, vs2) = g.igraph2pandas(ig)
g.nodes(vs2).bind(point_color='community').plot()

infer_labels()

Returns:

绘图器与neo4j

• 如果可用，优先使用 point_title/point_label

• 回退到节点ID

• 如果没有可用的节点，没有可能的候选节点，并且没有匹配的节点ID回退，则引发异常

示例

import graphistry
g = graphistry.nodes(pd.read_csv('nodes.csv'), 'id_col').infer_labels()
g.plot()

keep_nodes(nodes)

Parameters:

节点 (列表 | 任意)

Return type:

Plottable

layout_cugraph(layout='force_atlas2', params={}, kind='Graph', directed=True, G=None, bind_position=True, x_out_col='x', y_out_col='y', play=0)

使用cuGraph算法布局图形。有关布局列表，请参阅cugraph文档（目前仅支持force_atlas2）。

Parameters:

• 布局 (str) – cugraph布局方法的名称，例如force_atlas2

• params (dict) – 传递给底层cugraph方法的任何命名参数

• kind (CuGraphKind) – cugraph图的类型

• directed (bool) – 在转换为cugraph时，是否是有向的。（默认值为True）

• G (可选[任意]) – 要布局的cugraph图（G）。如果为None，则使用当前图。

• bind_position (bool) – 是否调用 bind(point_x=, point_y=)（默认为 True）

• x_out_col (str) – 写入x位置的属性。（默认值为‘x’）

• y_out_col (str) – 写入x位置的属性。（默认值为‘y’）

• play (可选[str]) – 如果定义，设置 settings(url_params={‘play’: play})。（默认值为 0）

Returns:

绘图仪

Return type:

绘图仪

Example: ForceAtlas2 layout

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['b','c','d','e']})
g = graphistry.edges(edges, 's', 'd')
g.layout_cugraph().plot()

Example: Change which column names are generated

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['b','c','d','e']})
g = graphistry.edges(edges, 's', 'd')
g2 = g.layout_cugraph('force_atlas2', x_out_col='my_x', y_out_col='my_y')
assert 'my_x' in g2._nodes
assert g2._point_x == 'my_x'
g2.plot()

Example: Pass parameters to layout methods

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['b','c','d','e']})
g = graphistry.edges(edges, 's', 'd')
g2 = g.layout_cugraph('forceatlas_2', params={'lin_log_mode': True, 'prevent_overlapping': True})
g2.plot()

layout_graphviz(prog='dot', args=None, directed=True, strict=False, graph_attr=None, node_attr=None, edge_attr=None, skip_styling=False, render_to_disk=False, path=None, format=None)

使用graphviz进行布局，例如层次树和有向无环图

需要安装pygraphviz Python绑定和graphviz本地库，请参阅https://pygraphviz.github.io/documentation/stable/install.html

查看 PROGS 以获取可用的布局算法

要将图像渲染到磁盘，请设置 render=True

Parameters:

• self (Plottable) – 基础图

• prog (graphistry.plugins_types.graphviz_types.Prog) – 布局算法 - “dot”, “neato”, …

• args (可选[str]) – 传递给graphviz命令行以进行布局的额外参数

• directed (bool) – 图是否为有向图（True，默认）或无向图（False）

• strict (bool) – 图是否严格（True）或不严格（False，默认值）

• graph_attr (Optional[Dict[graphistry.plugins_types.graphviz_types.GraphAttr, Any]]) – Graphviz 图形属性，参见 https://graphviz.org/docs/graph/

• node_attr (Optional[Dict[graphistry.plugins_types.graphviz_types.NodeAttr, Any]]) – Graphviz 节点属性，参见 https://graphviz.org/docs/nodes/

• edge_attr (Optional[Dict[graphistry.plugins_types.graphviz_types.EdgeAttr, Any]]) – Graphviz 边的属性，参见 https://graphviz.org/docs/edges/

• skip_styling (bool) – 是否跳过应用默认样式（False，默认）或不跳过（True）

• render_to_disk (bool) – 是否将图形渲染到磁盘（False，默认）或不渲染（True）

• path (可选[str]) – 当 render_to_disk=True 时，保存渲染图像的路径

• format (Optional[graphistry.plugins_types.graphviz_types.Format]) – 当render_to_disk=True时，渲染图像的格式

• drop_unsanitary (bool) – 是否删除不卫生的属性（False，默认）或不删除（True），建议用于敏感设置

Returns:

应用了布局和样式设置的图表，设置x/y

Return type:

Plottable

Example: Dot layout for rigid hierarchical layout of trees and directed acyclic graphs

import graphistry
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['b','c','d','e']})
g = graphistry.edges(edges, 's', 'd')
g.layout_graphviz('dot').plot()

示例：用于小图有机布局的Neato布局

import graphistry
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['b','c','d','e']})
g = graphistry.edges(edges, 's', 'd')
g.layout_graphviz('neato').plot()

示例：在图形级别设置graphviz属性

import graphistry
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['b','c','d','e']})
g = graphistry.edges(edges, 's', 'd')
g.layout_graphviz(
    prog='dot',
    graph_attr={
        'ratio': 10
    }
).plot()

示例：将渲染的图像保存为png格式到磁盘

import graphistry
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['b','c','d','e']})
g = graphistry.edges(edges, 's', 'd')
g.layout_graphviz(
    'dot',
    render_to_disk=True,
    path='graph.png',
    format='png'
)

示例：将渲染的图像保存为png格式，并传递渲染样式

import graphistry
edges = pd.DataFrame({
    's': ['a','b','c','d'],
    'd': ['b','c','d','e'],
    'color': ['red', None, None, 'yellow']
})
nodes = pd.DataFrame({
    'n': ['a','b','c','d','e'],
    'shape': ['circle', 'square', None, 'square', 'circle']
})
g = graphistry.edges(edges, 's', 'd')
g.layout_graphviz(
    'dot',
    render_to_disk=True,
    path='graph.png',
    format='png'
)

layout_igraph(layout, directed=None, use_vids=False, bind_position=True, x_out_col='x', y_out_col='y', play=0, params={})

使用igraph算法计算图形布局。有关布局的列表，请参见layout_algs或igraph文档。

Parameters:

• 布局 (str) – igraph.Graph.layout 方法的名称，例如 sugiyama

• directed (可选[布尔值]) – 在转换为igraph时，是否是有向的。如果为None，则尝试有向和无向。(默认值为None)

• use_vids (bool) – 是否使用igraph顶点id（非负整数）或任意节点id（False，默认值）

• bind_position (bool) – 是否调用 bind(point_x=, point_y=)（默认为 True）

• x_out_col (str) – 写入x位置的属性。（默认值为‘x’）

• y_out_col (str) – 写入x位置的属性。（默认值为‘y’）

• play (可选[str]) – 如果定义，设置 settings(url_params={‘play’: play})。（默认值为 0）

• params (dict) – 传递给底层igraph方法的任何命名参数

Returns:

绘图仪

Return type:

绘图仪

Example: Sugiyama layout

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['b','c','d','e']})
g = graphistry.edges(edges, 's', 'd')
g2 = g.layout_igraph('sugiyama')
assert 'x' in g2._nodes
g2.plot()

Example: Change which column names are generated

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['b','c','d','e']})
g = graphistry.edges(edges, 's', 'd')
g2 = g.layout_igraph('sugiyama', x_out_col='my_x', y_out_col='my_y')
assert 'my_x' in g2._nodes
assert g2._point_x == 'my_x'
g2.plot()

Example: Pass parameters to layout methods - Sort nodes by degree

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'd': ['b','c','d','e']})
g = graphistry.edges(edges, 's', 'd')
g2 = g.get_degrees()
assert 'degree' in g._nodes.columns
g3 = g.layout_igraph('sugiyama', params={'layers': 'degree'})
g3.plot()

layout_settings(play=None, locked_x=None, locked_y=None, locked_r=None, left=None, top=None, right=None, bottom=None, lin_log=None, strong_gravity=None, dissuade_hubs=None, edge_influence=None, precision_vs_speed=None, gravity=None, scaling_ratio=None)

设置布局选项。这些设置是累加的，会覆盖之前的设置。

对应于https://hub.graphistry.com/docs/api/1/rest/url/#urloptions中的选项

示例：动画径向布局

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'boss': ['c','c','e','e']})
nodes = pd.DataFrame({
    'n': ['a', 'b', 'c', 'd', 'e'],
    'y': [1,   1,   2,   3,   4],
    'x': [1,   1,   0,   0,   0],
})
g = (graphistry
    .edges(edges, 's', 'd')
    .nodes(nodes, 'n')
    .layout_settings(locked_r=True, play=2000)
g.plot()

Parameters:

• play (int | None)

• locked_x (bool | None)

• locked_y (bool | None)

• locked_r (bool | None)

• left (float | None)

• top (float | None)

• right (float | None)

• 底部 (浮点数 | 无)

• lin_log (bool | None)

• strong_gravity (bool | None)

• dissuade_hubs (bool | None)

• edge_influence (float | None)

• precision_vs_speed (float | None)

• gravity (float | None)

• scaling_ratio (float | None)

materialize_nodes(reuse=True, engine=EngineAbstract.AUTO)

Parameters:

• reuse (bool)

• engine (EngineAbstract | str)

Return type:

Plottable

name(name)

上传名称

Parameters:

name (str) – 上传名称

networkx2pandas(g)

networkx_checkoverlap(g)

如果节点属性已经存在于图中，则引发错误

nodes(nodes, node=None, *args, **kwargs)

指定节点集和相关数据。 如果是可调用的，将使用当前的Plotter和任何位置+命名参数进行调用。

必须包含边列表中引用的所有节点。

Parameters:

nodes (Pandas dataframe 或 Callable) – 节点及其属性。

Returns:

绘图仪

Return type:

绘图仪

Example

import graphistry

es = pandas.DataFrame({'src': [0,1,2], 'dst': [1,2,0]})
g = graphistry
    .bind(source='src', destination='dst')
    .edges(es)

vs = pandas.DataFrame({'v': [0,1,2], 'lbl': ['a', 'b', 'c']})
g = g.bind(node='v').nodes(vs)

g.plot()

Example

import graphistry

es = pandas.DataFrame({'src': [0,1,2], 'dst': [1,2,0]})
g = graphistry.edges(es, 'src', 'dst')

vs = pandas.DataFrame({'v': [0,1,2], 'lbl': ['a', 'b', 'c']})
g = g.nodes(vs, 'v)

g.plot()

Example

import graphistry

def sample_nodes(g, n):
    return g._nodes.sample(n)

df = pandas.DataFrame({'id': [0,1,2], 'v': [1,2,0]})

graphistry
    .nodes(df, 'id')
    ..nodes(sample_nodes, n=2)
    ..nodes(sample_nodes, None, 2)  # equivalent
    .plot()

nodexl(xls_or_url, source='default', engine=None, verbose=False)

pandas2igraph(edges, directed=True)

将pandas的边缘数据框转换为IGraph图。

使用当前绑定。默认将边视为有向。

Example

import graphistry
g = graphistry.bind()

es = pandas.DataFrame({'src': [0,1,2], 'dst': [1,2,0]})
g = g.bind(source='src', destination='dst')

ig = g.pandas2igraph(es)
ig.vs['community'] = ig.community_infomap().membership
g.bind(point_color='community').plot(ig)

pipe(graph_transform, *args, **kwargs)

从当前创建新的绘图仪

Parameters:

graph_transform (可调用)

Return type:

Plottable

Example: Simple

import graphistry

def fill_missing_bindings(g, source='src', destination='dst):
    return g.bind(source=source, destination=destination)

graphistry
    .edges(pandas.DataFrame({'src': [0,1,2], 'd': [1,2,0]}))
    .pipe(fill_missing_bindings, destination='d')  # binds 'src'
    .plot()

plot(graph=None, nodes=None, name=None, description=None, render='auto', skip_upload=False, as_files=False, memoize=True, extra_html='', override_html_style=None, validate=True)

将数据上传到Graphistry服务器并显示为iframe。

使用当前绑定的模式结构和视觉编码。 可选参数会覆盖当前的绑定。

在笔记本环境中使用时，还将显示可视化的iframe。

Parameters:

• graph (Any) – 边表（pandas, arrow, cudf）或图（NetworkX, IGraph）。

• nodes (Any) – 节点表（pandas, arrow, cudf）

• name (str) – 上传名称。

• 描述 (str) – 上传描述。

• render (可选[联合[布尔, RenderModes]] = "auto") – 是否使用本地环境（默认“auto”，True）、URL（“url”，False，None）、PyGraphistry Plottable（“g”）、thon对象（“ipython”）、交互式Databricks对象（“databricks”）或打开本地网页浏览器（“browser”）来渲染可视化。如果通过.settings()设置了_render，并且设置为None，则使用_render。

• skip_upload (bool) – 返回本应上传的节点/边/绑定。默认情况下，上传会发生。

• as_files (bool) – 在管理的文件PI下上传不同的节点/边文件。默认关闭，稳定后将切换为默认开启。

• memoize (bool) – 尝试记忆化 pandas/cudf->arrow 转换，包括跳过上传。默认开启。

• extra_html (可选[str]) – 允许向可视化iframe中注入任意HTML。

• override_html_style (可选[str]) – 设置完全自定义的样式标签。

• validate (可选[布尔值]) – 控制验证，包括编码的验证。

Example: Simple

import graphistry
es = pandas.DataFrame({'src': [0,1,2], 'dst': [1,2,0]})
graphistry
    .bind(source='src', destination='dst')
    .edges(es)
    .plot()

Example: Shorthand

import graphistry
es = pandas.DataFrame({'src': [0,1,2], 'dst': [1,2,0]})
graphistry
    .bind(source='src', destination='dst')
    .plot(es)

privacy(mode=None, notify=None, invited_users=None, message=None)

设置本地共享模式

Parameters:

• mode (可选[Mode]) – 可以是“private”、“public”或继承自全局的privacy()

• notify (可选[布尔值]) – 是否在上传时通过电子邮件通知收件人，默认为全局隐私设置()

• invited_users (可选[列表]) – 收件人列表，每个收件人为 {“email”: str, “action”: str}，其中 action 为 “10”（查看）或 “20”（编辑），默认为全局隐私()

• message (str | None) – 当notify=True时发送的电子邮件

需要一个具有共享功能的账户。

共享的数据集将出现在接收者的图库中。

如果模式设置为“private”，则只有受邀用户列表中的账户可以访问。模式“public”允许任何拥有URL的用户查看。

操作“10”（查看）提供读取权限，而操作“20”（编辑）提供编辑权限，例如更改共享模式。

当notify为true时，上传将触发向受邀者发送通知邮件。邮件将使用可视化的“.name()”。

当未指定设置时，它们将从全局graphistry.privacy()默认值继承

示例：将可视化限制为当前用户

import graphistry
graphistry.register(api=3, username='myuser', password='mypassword')

#Subsequent uploads default to using .privacy() settings
users_df = pd.DataFrame({'user': ['a','b','x'], 'boss': ['x', 'x', 'y']})
h = graphistry.hypergraph(users_df, direct=True)
g = h['graph']
g = g.privacy()  # default uploads to mode="private"
g.plot()

示例：默认公开可见的可视化

import graphistry
graphistry.register(api=3, username='myuser', password='mypassword')

#Subsequent uploads default to using .privacy() settings
users_df = pd.DataFrame({'user': ['a','b','x'], 'boss': ['x', 'x', 'y']})
h = graphistry.hypergraph(users_df, direct=True)
g = h['graph']
#g = g.privacy(mode="public")  # can skip calling .privacy() for this default
g.plot()

示例：默认与选定的团队成员共享，并保持通知为选择加入

import graphistry
graphistry.register(api=3, username='myuser', password='mypassword')

#Subsequent uploads default to using .privacy() settings
users_df = pd.DataFrame({'user': ['a','b','x'], 'boss': ['x', 'x', 'y']})
h = graphistry.hypergraph(users_df, direct=True)
g = h['graph']
g = g.privacy(
    mode="private",
    invited_users=[
        {"email": "friend1@acme.org", "action": "10"}, # view
        {"email": "friend2@acme.org", "action": "20"}, # edit
    ],
    notify=False)
g.plot()

示例：保持可视化公开并在上传时发送电子邮件通知

import graphistry
graphistry.register(api=3, username='myuser', password='mypassword')

#Subsequent uploads default to using .privacy() settings
users_df = pd.DataFrame({'user': ['a','b','x'], 'boss': ['x', 'x', 'y']})
h = graphistry.hypergraph(users_df, direct=True)
g = h['graph']
g = g.name('my cool viz')  # For friendlier invitations
g = g.privacy(
    mode="public",
    invited_users=[
        {"email": "friend1@acme.org", "action": "10"}, # view
        {"email": "friend2@acme.org", "action": "20"}, # edit
    ],
    notify=True)
g.plot()

protocol(v=None)

获取或设置服务器协议，例如，“https”

请注意，集合是作为PyGraphistry._config条目的全局变量，因此在多用户环境中要小心。

Parameters:

v (str | None)

Return type:

字符串

prune_self_edges()

Return type:

Plottable

python_remote_g(code, api_token=None, dataset_id=None, format='parquet', output_type='all', engine='cudf', run_label=None, validate=True)

Parameters:

• self (Plottable)

• code (str)

• api_token (str | None)

• dataset_id (str | None)

• format (Literal['json', 'csv', 'parquet'] | None)

• output_type (Literal['all', 'nodes', 'edges', 'shape'] | ~typing.Literal['table', 'shape'] | ~typing.Literal['json'] | None)

• engine (Literal['pandas', 'cudf'])

• run_label (str | None)

• validate (布尔值)

Return type:

Plottable

python_remote_json(code, api_token=None, dataset_id=None, engine='cudf', run_label=None, validate=True)

Parameters:

• self (Plottable)

• code (str)

• api_token (str | None)

• dataset_id (str | None)

• engine (Literal['pandas', 'cudf'])

• run_label (str | None)

• validate (布尔值)

Return type:

任何

python_remote_table(code, api_token=None, dataset_id=None, format='parquet', output_type='table', engine='cudf', run_label=None, validate=True)

Parameters:

• self (Plottable)

• code (str)

• api_token (str | None)

• dataset_id (str | None)

• format (Literal['json', 'csv', 'parquet'] | None)

• output_type (Literal['table', 'shape'] | None)

• engine (Literal['pandas', 'cudf'])

• run_label (str | None)

• validate (布尔值)

Return type:

数据框

reset_caches()

重置记忆缓存

scene_settings(menu=None, info=None, show_arrows=None, point_size=None, edge_curvature=None, edge_opacity=None, point_opacity=None)

设置场景选项。在之前的设置基础上进行添加。

对应于https://hub.graphistry.com/docs/api/1/rest/url/#urloptions中的选项

示例：隐藏箭头并拉直边缘

import graphistry, pandas as pd
edges = pd.DataFrame({'s': ['a','b','c','d'], 'boss': ['c','c','e','e']})
nodes = pd.DataFrame({
    'n': ['a', 'b', 'c', 'd', 'e'],
    'y': [1,   1,   2,   3,   4],
    'x': [1,   1,   0,   0,   0],
})
g = (graphistry
    .edges(edges, 's', 'd')
    .nodes(nodes, 'n')
    .scene_settings(show_arrows=False, edge_curvature=0.0)
g.plot()

Parameters:

• 菜单 (布尔 | 无)

• 信息 (布尔 | 无)

• show_arrows (bool | None)

• point_size (float | None)

• edge_curvature (float | None)

• edge_opacity (float | None)

• point_opacity (float | None)

server(v=None)

获取或设置服务器的基础名称，例如，“hub.graphistry.com”

请注意，集合是作为PyGraphistry._config条目的全局变量，因此在多用户环境中要小心。

Parameters:

v (str | None)

Return type:

字符串

settings(height=None, url_params={}, render=None)

指定iframe高度并添加URL参数字典。

该库负责对字典进行URI组件编码。

Parameters:

• height (int) – 高度，单位为像素。

• url_params (dict) – 要附加到URL的查询参数字典。

• render (bool) – 是否使用原生笔记本环境渲染可视化（默认为True），或返回可视化URL

style(fg=None, bg=None, page=None, logo=None)

设置通用视觉样式

请参阅 .bind() 和 .settings(url_params={}) 以获取其他样式选项，并使用 addStyle() 作为设置相同属性的另一种方式。

为了便于重用和可重放的笔记本，style() 调用是可链式调用的。调用不会影响旧的样式：它反而会返回一个新的 Plotter 实例，并将新样式添加到现有样式中。然后，旧的和新的样式都可以用于不同的图表。

style() 将完全替换现有样式设置中的任何已定义参数，而 addStyle() 将合并到先前的值上

Parameters:

• fg (dict) – 字典 {‘blendMode’: str}，包含任何有效的CSS混合模式

• bg (dict) – 页面背景属性的嵌套字典。{ ‘color’: str, ‘gradient’: {‘kind’: str, ‘position’: str, ‘stops’: list }, ‘image’: { ‘url’: str, ‘width’: int, ‘height’: int, ‘blendMode’: str }

• logo (dict) – 嵌套的logo属性字典。{ ‘url’: str, ‘autoInvert’: bool, ‘position’: str, ‘dimensions’: { ‘maxWidth’: int, ‘maxHeight’: int }, ‘crop’: { ‘top’: int, ‘left’: int, ‘bottom’: int, ‘right’: int }, ‘padding’: { ‘top’: int, ‘left’: int, ‘bottom’: int, ‘right’: int}, ‘style’: str}

• 页面 (字典) – 页面元数据设置的字典。{ ‘favicon’: str, ‘title’: str }

Returns:

绘图仪

Return type:

绘图仪

Example: Chained merge - results in url and blendMode being set, while color is dropped

g2 =  g.style(bg={'color': 'black'}, fg={'blendMode': 'screen'})
g3 = g2.style(bg={'image': {'url': 'http://site.com/watermark.png'}})

Example: Gradient background

g.style(bg={'gradient': {'kind': 'linear', 'position': 45, 'stops': [['rgb(0,0,0)', '0%'], ['rgb(255,255,255)', '100%']]}})

Example: Page settings

g.style(page={'title': 'Site - {{ name }}', 'favicon': 'http://site.com/logo.ico'})

tigergraph(protocol='http', server='localhost', web_port=14240, api_port=9000, db=None, user='tigergraph', pwd='tigergraph', verbose=False)

注册Tigergraph连接的默认设置

Parameters:

• protocol (可选[str]) – 用于联系数据库的协议。

• server (可选[str]) – 数据库的域名

• web_port (可选[整数])

• api_port (可选[整数])

• db (可选[str]) – 数据库的名称

• 用户 (可选[str])

• pwd (可选[str])

• verbose (可选[bool]) – 是否打印操作

Returns:

绘图仪

Return type:

绘图仪

Example: Standard

import graphistry
tg = graphistry.tigergraph(protocol='https', server='acme.com', db='my_db', user='alice', pwd='tigergraph2')                    

to_cudf()

Return type:

Plottable

to_cugraph(directed=True, include_nodes=True, node_attributes=None, edge_attributes=None, kind='Graph')

将当前图转换为cugraph.Graph对象

要分配边权重，请使用 g.bind(edge_weight=’some_col’).to_cugraph()

从pandas、cudf或dask_cudf数据框中加载

Parameters:

• directed (bool)

• include_nodes (bool)

• node_attributes (列表[字符串] | 无)

• edge_attributes (列表[字符串] | 无)

• 类型 (字面量['Graph', 'MultiGraph', 'BiPartiteGraph'])

to_igraph(directed=True, use_vids=False, include_nodes=True, node_attributes=None, edge_attributes=None)

将当前项目转换为igraph图。请参阅from_igraph中的示例。

Parameters:

• directed (bool) – 是否创建有向图（默认为 True）

• include_nodes (bool) – 是否摄取节点表，如果它存在（默认为 True）

• node_attributes (可选[列表[字符串]]) – 要加载的节点属性，None 表示全部（默认 None）

• edge_attributes (可选[列表[字符串]]) – 要加载的边属性，None 表示加载所有（默认 None）

• use_vids (bool) – 是否将ID解释为igraph顶点ID，这些ID必须是非负整数（默认值为False）

to_pandas()

Return type:

Plottable

upload(memoize=True, validate=True)

将数据上传到Graphistry服务器并返回为可绘制的对象。这是plot()的无头中心变体。

使用当前绑定的模式结构和视觉编码。 可选参数会覆盖当前的绑定。

上传成功后，返回的Plottable将设置字段dataset_id、url、edges_file_id，如果适用，还会设置nodes_file_id。

Parameters:

• memoize (bool) – 尝试记忆化 pandas/cudf->arrow 转换，包括跳过上传。默认为 true。

• validate (bool) – 控制验证，包括编码的验证。默认为 true。

Return type:

Plottable

Example: Simple

import graphistry
es = pandas.DataFrame({'src': [0,1,2], 'dst': [1,2,0]})
g1 = graphistry
    .bind(source='src', destination='dst')
    .edges(es)
g2 = g1.upload()
print(f'dataset id: {g2._dataset_id}, url: {g2._url}')

graphistry.PlotterBase.maybe_cudf()

graphistry.PlotterBase.maybe_dask_cudf()

graphistry.PlotterBase.maybe_dask_dataframe()

graphistry.PlotterBase.maybe_spark()