def from_biadjacency_matrix(
    matrix: np.ndarray,
    nodes_axis_0: list,
    nodes_axis_1: list,
    attributes_nodes_axis_0: dict,
    attributes_nodes_axis_1: dict,
    create_using: type = nx.MultiDiGraph,
) -> nx.MultiDiGraph:
    """
    Creates a bipartite graph from a biadjacency matrix using NetworkX.
    """
    # Initialize an empty graph with the specified type
    G = nx.empty_graph(n=0, create_using=create_using)
    
    # Add nodes from the first set (U) with bipartite=0 and additional attributes
    G.add_nodes_from(nodes_axis_0, bipartite=0, **attributes_nodes_axis_0)
    
    # Add nodes from the second set (V) with bipartite=1 and additional attributes
    G.add_nodes_from(nodes_axis_1, bipartite=1, **attributes_nodes_axis_1)

    # Find indices of non-zero elements in the matrix
    row_indices, col_indices = np.nonzero(matrix)
    
    # Map indices to node labels
    row_labels_nonzero = nodes_axis_0[row_indices]
    col_labels_nonzero = nodes_axis_1[col_indices]
    
    # Get the values at these non-zero positions
    values = matrix[row_indices, col_indices]
    
    # Create edges with 'flow' attribute based on matrix values
    edges = [(row, col, {'flow': val}) for row, col, val in zip(row_labels_nonzero, col_labels_nonzero, values)]
    
    # Add edges to the graph
    G.add_edges_from(edges)

    return G

def from_biadjacency_matrix(A, create_using=None, edge_attribute="weight",
                            top_nodelist=None, bottom_nodelist=None):
    G = nx.empty_graph(0, create_using)
    n, m = A.shape
    # Check lengths of nodelists match dimensions of A, if not specified set them to []
    top_nodelist, bottom_nodelist = _validate_initialize_bipartite_nodelists(A, top_nodelist, bottom_nodelist)

    # Make sure we get even the isolated nodes of the graph.
    G.add_nodes_from(range(n), bipartite=0)
    G.add_nodes_from(range(n, n + m), bipartite=1)
    # Create an iterable over (u, v, w) triples and for each triple, add an
    # edge from u to v with weight w.
    triples = ((u, n + v, d) for (u, v, d) in _generate_weighted_edges(A))
    # If the entries in the adjacency matrix are integers and the graph is a
    # multigraph, then create parallel edges, each with weight 1, for each
    # entry in the adjacency matrix. Otherwise, create one edge for each
    # positive entry in the adjacency matrix and set the weight of that edge to
    # be the entry in the matrix.
    if A.dtype.kind in ("i", "u") and G.is_multigraph():
        chain = itertools.chain.from_iterable
        triples = chain(((u, v, 1) for d in range(w)) for (u, v, w) in triples)
    G.add_weighted_edges_from(triples, weight=edge_attribute)

    # If the user provided nodelists, relabel the nodes in the graph
    mapping = dict(itertools.chain(zip(range(n), top_nodelist), zip(range(n, n + m), bottom_nodelist)))
    if len(mapping):
        nx.relabel_nodes(G, mapping, copy=False)
    return G

def _validate_initialize_bipartite_nodelists(A, top_nodelist, bottom_nodelist):
    n, m = A.shape
    # Validate nodelists if provided
    if top_nodelist is not None:
        if len(top_nodelist) != n:
            raise ValueError("Length of top_nodelist does not match number of rows in A ({n})")
    else:
        top_nodelist = []
    
    if bottom_nodelist is not None:
        if len(bottom_nodelist) != m:
            raise ValueError("Length of bottom_nodelist does not match number of columns in A ({m})")
    else:
        bottom_nodelist = []

    return top_nodelist, bottom_nodelist