def _convert_df_to_output_type(df, input_type, return_labels):
"""
Given a cudf.DataFrame df, convert it to a new type appropriate for the
graph algos in this module, based on input_type.
return_labels is only used for return values from cupy/scipy input types.
"""
if input_type in [Graph, DiGraph]:
return df
elif is_nx_graph_type(input_type):
return df_score_to_dictionary(df, "labels", "vertex")
elif is_matrix_type(input_type):
# Convert DF of 2 columns (labels, vertices) to the SciPy-style return
# value:
# n_components: int
# The number of connected components (number of unique labels).
# labels: ndarray
# The length-N array of labels of the connected components.
n_components = len(df["labels"].unique())
sorted_df = df.sort_values("vertex")
if return_labels:
if is_cp_matrix_type(input_type):
labels = cp.fromDlpack(sorted_df["labels"].to_dlpack())
else:
labels = sorted_df["labels"].to_numpy()
return (n_components, labels)
else:
return n_components
else:
raise TypeError(f"input type {input_type} is not a supported type.")
def _convert_df_to_output_type(df, input_type, return_predecessors):
"""
Given a cudf.DataFrame df, convert it to a new type appropriate for the
graph algos in this module, based on input_type.
return_predecessors is only used for return values from cupy/scipy input
types.
"""
if input_type in [Graph, DiGraph, MultiGraph, MultiDiGraph]:
return df
elif is_nx_graph_type(input_type):
return df.to_pandas()
elif is_matrix_type(input_type):
# A CuPy/SciPy input means the return value will be a 2-tuple of:
# distance: cupy.ndarray
# predecessor: cupy.ndarray
sorted_df = df.sort_values("vertex")
if return_predecessors:
if is_cp_matrix_type(input_type):
return (cp.fromDlpack(sorted_df["distance"].to_dlpack()),
cp.fromDlpack(sorted_df["predecessor"].to_dlpack()))
else:
return (sorted_df["distance"].to_numpy(),
sorted_df["predecessor"].to_numpy())
else:
if is_cp_matrix_type(input_type):
return cp.fromDlpack(sorted_df["distance"].to_dlpack())
else:
return sorted_df["distance"].to_numpy()
else:
raise TypeError(f"input type {input_type} is not a supported type.")
def _convert_df_series_to_output_type(df, offsets, input_type):
"""
Given a cudf.DataFrame df, convert it to a new type appropriate for the
graph algos in this module, based on input_type.
"""
if is_nx_graph_type(input_type):
return df.to_pandas(), offsets.values_host.tolist()
else:
return df, offsets
def _convert_graph_to_output_type(G, input_type):
"""
Given a cugraph.Graph, convert it to a new type appropriate for the
graph algos in this module, based on input_type.
"""
if is_nx_graph_type(input_type):
return cugraph_to_nx(G)
else:
return G
def _ensure_args(G, source, method, directed, return_predecessors, unweighted,
overwrite, indices):
"""
Ensures the args passed in are usable for the API api_name and returns the
args with proper defaults if not specified, or raises TypeError or
ValueError if incorrectly specified.
"""
# checks common to all input types
if (method is not None) and (method != "auto"):
raise ValueError("only 'auto' is currently accepted for method")
if (indices is not None) and (type(indices) == list):
raise ValueError("indices currently cannot be a list-like type")
if (indices is not None) and (source is not None):
raise TypeError("cannot specify both 'source' and 'indices'")
if (indices is None) and (source is None):
raise TypeError("must specify 'source' or 'indices', but not both")
G_type = type(G)
# Check for Graph-type inputs
if (G_type in [Graph, DiGraph]) or is_nx_graph_type(G_type):
exc_value = "'%s' cannot be specified for a Graph-type input"
if directed is not None:
raise TypeError(exc_value % "directed")
if return_predecessors is not None:
raise TypeError(exc_value % "return_predecessors")
if unweighted is not None:
raise TypeError(exc_value % "unweighted")
if overwrite is not None:
raise TypeError(exc_value % "overwrite")
directed = False
# Check for non-Graph-type inputs
else:
if (directed is not None) and (type(directed) != bool):
raise ValueError("'directed' must be a bool")
if (return_predecessors is not None) and \
(type(return_predecessors) != bool):
raise ValueError("'return_predecessors' must be a bool")
if (unweighted is not None) and (unweighted is not True):
raise ValueError("'unweighted' currently must be True if "
"specified")
if (overwrite is not None) and (overwrite is not False):
raise ValueError("'overwrite' currently must be False if "
"specified")
source = source if source is not None else indices
if return_predecessors is None:
return_predecessors = True
return (source, directed, return_predecessors)
def _ensure_args(api_name, G, directed, connection, return_labels):
"""
Ensures the args passed in are usable for the API api_name and returns the
args with proper defaults if not specified, or raises TypeError or
ValueError if incorrectly specified.
"""
G_type = type(G)
# Check for Graph-type inputs and set defaults if unset
if (G_type in [Graph, DiGraph]) or is_nx_graph_type(G_type):
exc_value = "'%s' cannot be specified for a Graph-type input"
if directed is not None:
raise TypeError(exc_value % "directed")
if return_labels is not None:
raise TypeError(exc_value % "return_labels")
directed = True
return_labels = True
# Check for non-Graph-type inputs and set defaults if unset
else:
directed = True if (directed is None) else directed
return_labels = True if (return_labels is None) else return_labels
# Handle connection type, based on API being called
if api_name == "strongly_connected_components":
if (connection is not None) and (connection != "strong"):
raise TypeError("'connection' must be 'strong' for "
f"{api_name}()")
connection = "strong"
elif api_name == "weakly_connected_components":
if (connection is not None) and (connection != "weak"):
raise TypeError("'connection' must be 'weak' for " f"{api_name}()")
connection = "weak"
else:
raise RuntimeError("invalid API name specified (internal): "
f"{api_name}")
return (directed, connection, return_labels)
def _ensure_args(G, start, i_start, directed):
"""
Ensures the args passed in are usable for the API api_name and returns the
args with proper defaults if not specified, or raises TypeError or
ValueError if incorrectly specified.
"""
# checks common to all input types
if (start is not None) and (i_start is not None):
raise TypeError("cannot specify both 'start' and 'i_start'")
if (start is None) and (i_start is None):
raise TypeError("must specify 'start' or 'i_start', but not both")
G_type = type(G)
# Check for Graph-type inputs
if (G_type in [Graph, DiGraph]) or is_nx_graph_type(G_type):
if directed is not None:
raise TypeError("'directed' cannot be specified for a "
"Graph-type input")
start = start if start is not None else i_start
if directed is None:
directed = True
return (start, directed)
