<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def get_vulnerability( source, sink, triggers, lattice, cfg, interactive, blackbox_mapping ):
 """Get vulnerability between source and sink if it exists. Uses triggers to find sanitisers. Note: When a secondary node is in_constraint with the sink but not the source, the secondary is a save_N_LHS node made in process_function in expr_visitor. Args: source(TriggerNode):
 TriggerNode of the source. sink(TriggerNode):
 TriggerNode of the sink. triggers(Triggers):
 Triggers of the CFG. lattice(Lattice):
 the lattice we're analysing. cfg(CFG):
 .blackbox_assignments used in is_unknown, .nodes used in build_def_use_chain interactive(bool):
 determines if we ask the user about blackbox functions not in the mapping file. blackbox_mapping(dict):
 A map of blackbox functions containing whether or not they propagate taint. Returns: A Vulnerability if it exists, else None """

    nodes_in_constraint = [
        secondary
        for secondary in reversed(source.secondary_nodes)
        if lattice.in_constraint(
            secondary,
            sink.cfg_node
        )
    ]
    nodes_in_constraint.append(source.cfg_node)
    if sink.trigger.all_arguments_propagate_taint:
        sink_args = get_sink_args(sink.cfg_node)
    else:
        sink_args = get_sink_args_which_propagate(sink, sink.cfg_node.ast_node)

    tainted_node_in_sink_arg = get_tainted_node_in_sink_args(
        sink_args,
        nodes_in_constraint,
    )

    if tainted_node_in_sink_arg:
        vuln_deets = {
            'source': source.cfg_node,
            'source_trigger_word': source.trigger_word,
            'sink': sink.cfg_node,
            'sink_trigger_word': sink.trigger_word
        }

        sanitiser_nodes = set()
        potential_sanitiser = None
        if sink.sanitisers:
            for sanitiser in sink.sanitisers:
                for cfg_node in triggers.sanitiser_dict[sanitiser]:
                    if isinstance(cfg_node, AssignmentNode):
                        sanitiser_nodes.add(cfg_node)
                    elif isinstance(cfg_node, IfNode):
                        potential_sanitiser = cfg_node

        def_use = build_def_use_chain(
            cfg.nodes,
            lattice
        )

        for chain in get_vulnerability_chains(
            source.cfg_node,
            sink.cfg_node,
            def_use
        ):
            vulnerability_type, interactive = how_vulnerable(
                chain,
                blackbox_mapping,
                sanitiser_nodes,
                potential_sanitiser,
                cfg.blackbox_assignments,
                interactive,
                vuln_deets
            )
            if vulnerability_type == VulnerabilityType.FALSE:
                continue

            vuln_deets['reassignment_nodes'] = chain

            return vuln_factory(vulnerability_type)(**vuln_deets), interactive

    return None, interactive