nndeploy.dag.node

Functions

add_global_import_lib(path)	Add a path to the global import library.
add_global_import_lib_class(module_name, ...)	Add a class to the global import library.
add_global_import_lib_function(module_name, ...)	Add a function to the global import library.
add_global_import_lib_module(module_name)	Add a module to the global import library.
add_remove_node_keys(node_keys)	Add node keys to the removal list.
create_node(node_key, node_name[, inputs, ...])	Create a node instance using the registered creator.
get_all_node_json()	Get JSON representation of all registered nodes organized in a tree structure.
get_node_json(node_key)	Get the JSON representation of a node type.
get_node_keys()	Get all registered node keys.
import_global_import_lib()	Import all items in the global import library.
register_node(node_key, node_creator)	Register a node creator with a specific key.
sub_remove_node_keys(node_keys)	Remove node keys from the removal list.

Classes

ImportLib()	Library import manager for handling dynamic library and Python module imports.
Node(name[, inputs, outputs])	Main Node class that wraps the C++ Node implementation.
NodeCreator()	Abstract base class for creating nodes.
NodeDesc([name, inputs, outputs, key])	Node description class that wraps the C++ NodeDesc.

class nndeploy.dag.node.NodeDesc(name: str = '', inputs: list[str] = None, outputs: list[str] = None, key: str = None)

基类：NodeDesc

Node description class that wraps the C++ NodeDesc.

This class provides a Python interface for node descriptions, including name, inputs, outputs, and optional key.

__init__(name: str = '', inputs: list[str] = None, outputs: list[str] = None, key: str = None)

Initialize the node description.

参数:

• name – Node name

• inputs – List of input names

• outputs – List of output names

• key – Optional node key

get_key() → str

Get the unique key of the node.

get_name() → str

Get the node name.

get_inputs() → list[str]

Get the list of input names.

get_outputs() → list[str]

Get the list of output names.

serialize(target: str)

Serialize the node description to a string.

deserialize(target: str)

Deserialize the node description from a string.

load_file(self: nndeploy._nndeploy_internal.dag.NodeDesc, path: str) → nndeploy._nndeploy_internal.base.Status

save_file(self: nndeploy._nndeploy_internal.dag.NodeDesc, path: str) → nndeploy._nndeploy_internal.base.Status

class nndeploy.dag.node.Node(name: str, inputs=None, outputs=None)

基类：Node

Main Node class that wraps the C++ Node implementation.

This class provides a Python interface for graph nodes, including initialization, execution, parameter management, and I/O handling.

__init__(name: str, inputs=None, outputs=None)

Initialize the node.

参数:

• name – The name of the node

• inputs – List of input edges or None

• outputs – List of output edges or None

set_key(key: str)

Set the unique key for the node.

get_key() → str

Get the unique key of the node.

set_name(name: str)

Set the name of the node.

get_name() → str

Get the name of the node.

set_developer(developer: str)

Set the developer information for the node.

get_developer() → str

Get the developer information of the node.

set_source(source: str)

Set the source code repository information for the node.

get_source() → str

Get the source code repository information of the node.

set_desc(desc: str)

Set the description of the node.

get_desc() → str

Get the description of the node.

set_graph(graph)

Set the parent graph for this node.

get_graph()

Get the parent graph of this node.

set_device_type(device_type: DeviceType)

Set the device type for node execution.

get_device_type() → DeviceType

Get the device type of the node.

set_param(param)

Set the parameters for the node.

get_param()

Get the parameters of the node.

set_external_param(key: str, external_param)

Set external parameters using key-value pairs.

get_external_param(key: str)

Get external parameters by key.

add_resource_without_state(key: str, value)

Add stateless resources using key-value pairs.

get_resource_without_state(key: str)

Get stateless resources by key.

create_resource_with_state(key: str) → Edge

Create stateful resources and return an edge pointer.

add_resource_with_state(key: str, edge: Edge)

Add stateful resources using key and edge.

get_resource_with_state(key: str) → Edge

Get stateful resource edge by key.

set_version(version: str)

Set the version of the node.

get_version() → str

Get the version of the node.

set_required_params(required_params: list)

Set the list of required parameters.

add_required_param(required_param: str)

Add a required parameter.

remove_required_param(required_param: str)

Remove a required parameter.

clear_required_params()

Clear the list of required parameters.

get_required_params() → list

Get the list of required parameters.

set_ui_params(ui_params: list)

Set the list of UI parameters.

add_ui_param(ui_param: str)

Add a UI parameter.

remove_ui_param(ui_param: str)

Remove a UI parameter.

clear_ui_params()

Clear the list of UI parameters.

get_ui_params() → list

Get the list of UI parameters.

set_io_params(io_params: list)

Set the list of IO parameters.

add_io_param(io_param: str)

Add an IO parameter.

remove_io_param(io_param: str)

Remove an IO parameter.

clear_io_params()

Clear the list of IO parameters.

get_io_params() → list

Get the list of IO parameters.

set_dropdown_params(dropdown_params: dict)

Set the list of dropdown parameters.

add_dropdown_param(dropdown_param: str, dropdown_values: list)

Add a dropdown parameter.

remove_dropdown_param(dropdown_param: str)

Remove a dropdown parameter.

clear_dropdown_params()

Clear the list of dropdown parameters.

set_input(input, index: int = -1)

Set input at the specified index.

set_iter_input(input, index: int = -1)

Set iterative input at the specified index.

set_output(output, index: int = -1)

Set output at the specified index.

set_inputs(inputs)

Set all inputs for the node.

set_outputs(outputs)

Set all outputs for the node.

get_input(index: int = 0)

Get input at the specified index.

get_output(index: int = 0)

Get output at the specified index.

get_input_data(index: int = 0)

Get input data at the specified index.

set_output_data(output, index: int = 0, is_external: bool = True)

Set output data at the specified index.

get_all_input()

Get all inputs of the node.

get_all_output()

Get all outputs of the node.

get_constructed() → bool

Check if the node has been constructed.

set_parallel_type(parallel_type: ParallelType)

Set the parallel execution type for the node.

get_parallel_type() → ParallelType

Get the parallel execution type of the node.

set_inner_flag(flag: bool)

Set the inner flag for the node.

set_initialized_flag(flag: bool)

Set the initialization flag for the node.

get_initialized() → bool

Check if the node has been initialized.

set_time_profile_flag(flag: bool)

Enable or disable time profiling for the node.

get_time_profile_flag() → bool

Check if time profiling is enabled.

set_debug_flag(flag: bool)

Enable or disable debug mode for the node.

get_debug_flag() → bool

Check if debug mode is enabled.

set_running_flag(flag: bool)

Set the running flag for the node.

is_running() → bool

Check if the node is currently running.

get_run_size() → int

Get the run size of the node.

get_completed_size() → int

Get the completed size of the node.

get_run_status() → RunStatus

Get the run status of the node.

set_trace_flag(flag: bool)

Enable or disable tracing for the node.

get_trace_flag() → bool

Check if tracing is enabled.

set_graph_flag(flag: bool)

Set the graph flag for the node.

get_graph_flag() → bool

Check if the graph flag is set.

set_node_type(node_type)

Set the node type.

get_node_type()

Get the node type.

set_io_type(io_type)

Set the I/O type for the node.

get_io_type()

Get the I/O type of the node.

set_loop_count(loop_count: int)

Set the loop count for the node.

get_loop_count() → int

Get the loop count of the node.

set_stream(stream)

Set the execution stream for the node.

get_stream()

Get the execution stream of the node.

set_input_type_info(input_type_info: EdgeTypeInfo, desc: str = '')

Set the input type information for the node.

set_input_type(input_type: type, desc: str = '')

Set the input type for the node.

参数:

input_type – The input type

返回:

Status code

get_input_type_info() → EdgeTypeInfo

Get the input type information of the node.

set_output_type_info(output_type_info: EdgeTypeInfo, desc: str = '')

Set the output type information for the node.

set_output_type(output_type: type, desc: str = '')

Set the output type for the node.

get_output_type_info() → EdgeTypeInfo

Get the output type information of the node.

init()

Initialize the node.

deinit()

Deinitialize the node and clean up resources.

get_memory_size() → int

Get the memory size required by the node.

set_memory(buffer: Buffer)

Set the memory buffer for the node.

update_input()

Update the input data for the node.

run()

Execute the node’s main computation.

synchronize() → bool

Synchronize the node execution.

check_inputs(inputs) → bool

Validate the input data.

check_outputs(outputs_name) → bool

Validate the output names.

get_real_outputs_name()

Get the actual output names.

serialize() → str

Serialize the node to a JSON string.

save_file(path: str)

Save the node configuration to a file.

deserialize(target: str)

Deserialize the node from a JSON string.

load_file(path: str)

Load the node configuration from a file.

create_internal_output_edge(self: nndeploy._nndeploy_internal.dag.Node, name: str) → nndeploy::dag::Edge

default_param(self: nndeploy._nndeploy_internal.dag.Node) → nndeploy._nndeploy_internal.base.Status

forward(*args, **kwargs)

Overloaded function.

1. forward(self: nndeploy._nndeploy_internal.dag.Node, inputs: list[nndeploy::dag::Edge]) -> list[nndeploy::dag::Edge]

2. forward(self: nndeploy._nndeploy_internal.dag.Node) -> list[nndeploy::dag::Edge]

3. forward(self: nndeploy._nndeploy_internal.dag.Node, input: nndeploy::dag::Edge) -> list[nndeploy::dag::Edge]

get_composite_node(self: nndeploy._nndeploy_internal.dag.Node) → nndeploy::dag::CompositeNode

get_dropdown_params(self: nndeploy._nndeploy_internal.dag.Node) → dict[str, list[str]]

get_input_count(self: nndeploy._nndeploy_internal.dag.Node) → int

get_input_index(self: nndeploy._nndeploy_internal.dag.Node, name: str) → int

get_input_name(self: nndeploy._nndeploy_internal.dag.Node, index: int = 0) → str

get_input_names(self: nndeploy._nndeploy_internal.dag.Node) → list[str]

get_output_count(self: nndeploy._nndeploy_internal.dag.Node) → int

get_output_index(self: nndeploy._nndeploy_internal.dag.Node, name: str) → int

get_output_name(self: nndeploy._nndeploy_internal.dag.Node, index: int = 0) → str

get_output_names(self: nndeploy._nndeploy_internal.dag.Node) → list[str]

is_dynamic_input(self: nndeploy._nndeploy_internal.dag.Node) → bool

is_dynamic_output(self: nndeploy._nndeploy_internal.dag.Node) → bool

is_inputs_changed(self: nndeploy._nndeploy_internal.dag.Node, inputs: list[nndeploy::dag::Edge]) → bool

set_composite_node(self: nndeploy._nndeploy_internal.dag.Node, composite_node: nndeploy::dag::CompositeNode) → nndeploy._nndeploy_internal.base.Status

set_dynamic_input(self: nndeploy._nndeploy_internal.dag.Node, is_dynamic_input: bool) → None

set_dynamic_output(self: nndeploy._nndeploy_internal.dag.Node, is_dynamic_output: bool) → None

set_input_name(self: nndeploy._nndeploy_internal.dag.Node, name: str, index: int = 0) → nndeploy._nndeploy_internal.base.Status

set_input_names(self: nndeploy._nndeploy_internal.dag.Node, names: list[str]) → nndeploy._nndeploy_internal.base.Status

set_input_shared_ptr(self: nndeploy._nndeploy_internal.dag.Node, input: nndeploy::dag::Edge, index: int = -1) → nndeploy._nndeploy_internal.base.Status

set_inputs_shared_ptr(self: nndeploy._nndeploy_internal.dag.Node, inputs: list[nndeploy::dag::Edge]) → nndeploy._nndeploy_internal.base.Status

set_output_name(self: nndeploy._nndeploy_internal.dag.Node, name: str, index: int = 0) → nndeploy._nndeploy_internal.base.Status

set_output_names(self: nndeploy._nndeploy_internal.dag.Node, names: list[str]) → nndeploy._nndeploy_internal.base.Status

set_output_shared_ptr(self: nndeploy._nndeploy_internal.dag.Node, output: nndeploy::dag::Edge, index: int = -1) → nndeploy._nndeploy_internal.base.Status

set_outputs_shared_ptr(self: nndeploy._nndeploy_internal.dag.Node, outputs: list[nndeploy::dag::Edge]) → nndeploy._nndeploy_internal.base.Status

to_static_graph(self: nndeploy._nndeploy_internal.dag.Node) → nndeploy._nndeploy_internal.base.Status

class nndeploy.dag.node.NodeCreator

基类：NodeCreator

Abstract base class for creating nodes.

This class should be subclassed to implement specific node creation logic.

__init__(self: nndeploy._nndeploy_internal.dag.NodeCreator) → None

create_node(name: str, inputs: list[nndeploy.dag.edge.Edge], outputs: list[nndeploy.dag.edge.Edge])

Create a new node instance.

This method must be implemented by subclasses.

参数:

• name – The name of the node

• inputs – List of input edges

• outputs – List of output edges

返回:

The created node instance

create_node_shared_ptr(self: nndeploy._nndeploy_internal.dag.NodeCreator, arg0: str, arg1: list[nndeploy::dag::Edge], arg2: list[nndeploy::dag::Edge]) → nndeploy._nndeploy_internal.dag.Node

nndeploy.dag.node.get_node_keys()

Get all registered node keys.

nndeploy.dag.node.register_node(node_key: str, node_creator: NodeCreator)

Register a node creator with a specific key.

参数:

• node_key – The unique key for the node type

• node_creator – The creator instance for this node type

nndeploy.dag.node.create_node(node_key: str, node_name: str, inputs: list[nndeploy.dag.edge.Edge] = None, outputs: list[nndeploy.dag.edge.Edge] = None)

Create a node instance using the registered creator.

参数:

• node_key – The key of the node type to create

• node_name – The name for the new node instance

• inputs – Optional list of input edges

• outputs – Optional list of output edges

返回:

The created node instance

nndeploy.dag.node.get_node_json(node_key: str)

Get the JSON representation of a node type.

This function creates a temporary node instance, initializes it with default parameters, and serializes it to JSON format.

参数:

node_key – The key of the node type

返回:

JSON string representation of the node, or empty string if failed

class nndeploy.dag.node.ImportLib

基类：object

Library import manager for handling dynamic library and Python module imports.

This class manages the import of various types of libraries and modules, including dynamic libraries (.so, .dll, .dylib), Python files, and modules.

__init__()

add_path(path: str, update: bool = False)

Add a path for import (library, Python file, or directory).

参数:

• path – The path to add

• update – Whether to update if already exists

add_module(module_name: str, update: bool = False)

Add a module name for import.

参数:

• module_name – The name of the module to import

• update – Whether to update if already exists

add_class(module_name: str, class_name: str, update: bool = False)

Add a class to import from a specific module.

参数:

• module_name – The name of the module containing the class

• class_name – The name of the class to import

• update – Whether to update if already exists

add_function(module_name: str, function_name: str, update: bool = False)

Add a function to import from a specific module.

参数:

• module_name – The name of the module containing the function

• function_name – The name of the function to import

• update – Whether to update if already exists

import_all()

Import all registered libraries, modules, classes, and functions.

load_py_file(py_file_path: str)

Load a Python file directly as a module.

参数:

py_file_path – Path to the Python file

返回:

The loaded module or None if failed

import_module(module_name: str)

Import a module by name.

import_class(module_name: str, class_name: str)

Import a class from a module.

import_function(module_name: str, function_name: str)

Import a function from a module.

nndeploy.dag.node.add_global_import_lib(path: str)

Add a path to the global import library.

参数:

path – The path to add (file or directory)

nndeploy.dag.node.add_global_import_lib_module(module_name: str)

Add a module to the global import library.

nndeploy.dag.node.add_global_import_lib_class(module_name: str, class_name: str)

Add a class to the global import library.

nndeploy.dag.node.add_global_import_lib_function(module_name: str, function_name: str)

Add a function to the global import library.

nndeploy.dag.node.import_global_import_lib()

Import all items in the global import library.

nndeploy.dag.node.add_remove_node_keys(node_keys: list[str])

Add node keys to the removal list.

参数:

node_keys – List of node keys to exclude

nndeploy.dag.node.sub_remove_node_keys(node_keys: list[str])

Remove node keys from the removal list.

参数:

node_keys – List of node keys to include back

nndeploy.dag.node.get_all_node_json()

Get JSON representation of all registered nodes organized in a tree structure.

This function creates a hierarchical representation of all nodes based on their namespace structure, with branch nodes representing namespaces and leaf nodes representing actual node implementations.

返回:

JSON string containing all nodes in tree format