nova-clone 0.1.0__py3-none-any.whl

nova_clone/__init__.py

@@ -0,0 +1 @@
+from .algorithm import clone_calling_algorithm

nova_clone/algorithm/__init__.py

@@ -0,0 +1,2 @@
+from ._clone_calling_algorithm import clone_calling_algorithm
+from ._clone_call_ops import merge_clones, drop_clones

nova_clone/algorithm/_build_intbc_graph.py

@@ -0,0 +1,135 @@
+"""
+Module for building an IntBC graph from a list of intBC tables.
+
+The main function exposed by this module is `build_intbc_graph`.
+"""
+
+import logging
+import sys
+import time
+from collections import defaultdict
+from typing import Set
+
+from ._types import *
+from ._utils import _cell_intbc_sets_from_intbc_tables
+
+
+def _init_logger():
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.INFO)
+    fmt_str = "[%(asctime)s] - %(name)s - %(levelname)s - %(message)s"
+    formatter = logging.Formatter(fmt_str)
+
+    consoleHandler = logging.StreamHandler(sys.stdout)
+    consoleHandler.setFormatter(formatter)
+    logger.addHandler(consoleHandler)
+
+
+_init_logger()
+
+
+class BuildIntBCGraphReturnType(NamedTuple):
+    """
+    Object returned by the build_intbc_graph function.
+
+    Attributes:
+        intbc_graph: The intBC graph, of type GraphType.
+        total_time: Total time taken.
+    """
+
+    intbc_graph: GraphType
+    total_time: float
+
+
+def build_intbc_graph(
+    intbc_table_per_sample: Dict[SampleNameType, IntBCTableType],
+) -> BuildIntBCGraphReturnType:
+    """
+    Build the intBC graph from a list of intBC tables.
+
+    Args:
+        intbc_table_per_sample: intBC table per sample.
+
+    Returns:
+        intbc_graph: The intBC graph, of type GraphType.
+    """
+    st = time.time()
+    logger = logging.getLogger(__name__)
+    logger.info("Going to build_intbc_graph ...")
+    edge_counts = defaultdict(lambda: defaultdict(int))
+    node_counts = defaultdict(int)
+    cell_intbc_sets = _cell_intbc_sets_from_intbc_tables(
+        intbc_table_per_sample=intbc_table_per_sample,
+    )
+    for cell_intbc_set in cell_intbc_sets.values():
+        for intbc_1 in cell_intbc_set:
+            node_counts[intbc_1] += 1
+            for intbc_2 in cell_intbc_set:
+                if intbc_1 == intbc_2:
+                    continue
+                edge_counts[intbc_1][intbc_2] += 1
+    # Make sure that intBCs with no neighbors are present in the edge dict!
+    for intbc in node_counts:
+        edge_counts[intbc]
+    # Convert to a normal Dict
+    edge_counts = {x: {y: z for (y, z) in d.items()} for (x, d) in edge_counts.items()}
+    node_counts = {x: y for (x, y) in node_counts.items()}
+    intbc_graph = (edge_counts, node_counts)
+    total_time = time.time() - st
+    res = BuildIntBCGraphReturnType(
+        intbc_graph=intbc_graph,
+        total_time=total_time,
+    )
+    num_nodes = len(node_counts)
+    num_edges = sum([len(x) for x in edge_counts.values()]) // 2
+    logger.info(
+        f"IntBC graph has {num_nodes} nodes and {num_edges} edges. Density level: {100.0 * num_edges / (num_nodes * (num_nodes - 1.0) / 2.0 + 1e-9):.2f}%"
+    )
+    logger.info(f"Done with build_intbc_graph! Total time: {total_time}")
+    return res
+
+
+def test_build_intbc_graph():
+    """
+    Basic test.
+    """
+    intbc_table_1 = pd.DataFrame(
+        data=[
+            ["cellBC_1", "AAA", 40],
+            ["cellBC_1", "BBB", 40],
+            ["cellBC_2", "AAA", 40],
+            ["cellBC_2", "BBB", 40],
+            ["cellBC_2", "CCC", 40],
+            ["cellBC_3", "DDD", 40],
+            ["cellBC_3", "EEE", 40],
+            ["cellBC_3", "FFF", 40],
+        ],
+        columns=["cellBC", "intBC", "UMI_count"],
+    )
+    intbc_table_2 = pd.DataFrame(
+        data=[
+            ["cellBC_1", "EEE", 10],
+            ["cellBC_1", "FFF", 40],
+            ["cellBC_2", "GGG", 40],  # Just observed once
+        ],
+        columns=["cellBC", "intBC", "UMI_count"],
+    )
+    graph = build_intbc_graph(
+        intbc_table_per_sample={
+            "sample1": intbc_table_1,
+            "sample2": intbc_table_2,
+        },
+    ).intbc_graph
+    expected_graph = (
+        {
+            "AAA": {"BBB": 2, "CCC": 1},
+            "BBB": {"AAA": 2, "CCC": 1},
+            "CCC": {"AAA": 1, "BBB": 1},
+            "DDD": {"EEE": 1, "FFF": 1},
+            "EEE": {"DDD": 1, "FFF": 2},
+            "FFF": {"DDD": 1, "EEE": 2},
+            "GGG": {},
+        },
+        {"AAA": 2, "BBB": 2, "CCC": 1, "DDD": 1, "EEE": 2, "FFF": 2, "GGG": 1},
+    )
+    assert graph == expected_graph

nova_clone/algorithm/_call_clones_from_coresets.py

@@ -0,0 +1,235 @@
+"""
+Module for calling clones once coresets have been identified.
+
+The main function exposed by this module is `call_clones_from_coresets`.
+"""
+
+import time
+
+import editdistance
+import numpy as np
+import pandas as pd
+import tqdm
+
+from ._compute_cellbc_vs_coreset_overlap_matrix import (
+    compute_cellbc_vs_coreset_overlap_matrix,
+)
+from ._prune_low_umi_count_intbcs import prune_low_umi_count_intbcs
+from ._types import *
+from ._utils import _cell_intbc_sets_from_intbc_tables
+
+import logging
+import sys
+
+from ._types import *
+
+
+def _init_logger():
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.INFO)
+    fmt_str = "[%(asctime)s] - %(name)s - %(levelname)s - %(message)s"
+    formatter = logging.Formatter(fmt_str)
+
+    consoleHandler = logging.StreamHandler(sys.stdout)
+    consoleHandler.setFormatter(formatter)
+    logger.addHandler(consoleHandler)
+
+
+_init_logger()
+
+
+class CallClonesFromCoresetsReturnType(NamedTuple):
+    """
+    Object returned by the `call_clones_from_coresets` function.
+
+    Attributes:
+        clone_call: The clone call.
+        total_time: Total time taken.
+    """
+
+    clone_call: CloneCallType
+    total_time: float
+
+
+def call_clones_from_coresets(
+    intbc_table_per_sample: Dict[SampleNameType, IntBCTableType],
+    min_intbc_umi_count: int,
+    coresets: List[Coreset[str]],
+    min_overlap_for_assigning_cellbc: int,
+    min_intbc_counts_for_adding_intbc_to_clone_intbc_set: int,
+    min_intbc_fraction_for_adding_to_clone_intbc_set: float,
+    edit_distance_cutoff: int,
+    custom_intbc_filtering_function: str,
+) -> CallClonesFromCoresetsReturnType:
+    """
+    Call clones given the coresets characterizing each clone.
+    """
+    st = time.time()
+
+    # Validate arguments
+    validate_intbc_table_per_sample(intbc_table_per_sample=intbc_table_per_sample)
+
+    # Filter intBCs based on min_intbc_umi_count
+    all_cellbc = set(
+        list(
+            _cell_intbc_sets_from_intbc_tables(
+                intbc_table_per_sample=intbc_table_per_sample
+            ).keys()
+        )
+    )
+    intbc_table_per_sample = prune_low_umi_count_intbcs(
+        intbc_table_per_sample=intbc_table_per_sample,
+        min_intbc_umi_count=min_intbc_umi_count
+    ).intbc_table_per_sample
+    cell_intbc_sets = _cell_intbc_sets_from_intbc_tables(
+        intbc_table_per_sample=intbc_table_per_sample,
+    )
+
+    cellbc_vs_coreset_overlap_matrix = compute_cellbc_vs_coreset_overlap_matrix(  # We MUST prune low-count UMIs before doing this! Else the background RNA will mess it up. In constrast, it's OK to not have discarded sequencing errors (bc they are not in the coresets anyway) nor homoplastic intBCs (because they are also not in the coresets anyway). Sequencing errors and homoplastic intBCs will be recovered de-novo.
+        cellbc_intbc_sets=cell_intbc_sets,
+        coresets=coresets,
+    ).cellbc_vs_coreset_overlap_matrix
+
+    cells = sorted(list(cell_intbc_sets.keys()))
+    num_clones = cellbc_vs_coreset_overlap_matrix.shape[1]
+    num_cells = cellbc_vs_coreset_overlap_matrix.shape[0]
+    assert len(cells) == num_cells
+
+    # First compute clone_intbc_counts by using the confidently mapped cells.
+    clone_intbc_counts = {
+        clone_idx: defaultdict(int) for clone_idx in range(num_clones)
+    }
+    clone_mapping = {cell: {} for cell in cell_intbc_sets}
+    clone_to_cells_mapping = {clone_idx: set() for clone_idx in range(num_clones)}
+    clone_sizes = defaultdict(int)
+    for cell in tqdm.tqdm(cells):
+        clones_assigned = list(
+            np.where(
+                cellbc_vs_coreset_overlap_matrix.loc[cell, :]
+                >= min_overlap_for_assigning_cellbc
+            )[0]
+        )
+        clone_mapping[cell] = set(clones_assigned)
+        if len(clones_assigned) == 1:
+            # Is confidently assigned, so use to compute clone intBC sets
+            clone_idx = clones_assigned[0]
+            clone_to_cells_mapping[clone_idx].add(cell)
+            clone_sizes[clone_idx] += 1
+            for intbc in cell_intbc_sets[cell]:
+                clone_intbc_counts[clone_idx][intbc] += 1
+
+    # Now it's time to figure out the intBC sets of each clone from their intBC
+    # counts
+    clone_intbc_sets = {}
+    for clone_idx in tqdm.tqdm(range(num_clones)):
+        clone_size = clone_sizes[clone_idx]
+        kept_intbcs = []
+        intbc_counts = sorted(
+            clone_intbc_counts[clone_idx].items(), key=lambda x: -x[1]
+        )
+        for intbc, counts in intbc_counts:
+            if custom_intbc_filtering_function(intbc):
+                # Is weird, so we discard it immediately
+                continue
+            else:
+                # First see if it looks anything like another *kept* intBC
+                ds = {
+                    kept_intbc: editdistance.eval(intbc, kept_intbc)
+                    for kept_intbc in kept_intbcs
+                }
+                close_kept_intbcs = [
+                    kept_intbc
+                    for (kept_intbc, d) in ds.items()
+                    if d <= edit_distance_cutoff
+                ]
+                if len(close_kept_intbcs) == 0:
+                    # If it meets the fraction & count cutoff, we keep it
+                    intbc_fraction = counts / clone_size
+                    if (
+                        (
+                            (
+                                intbc_fraction
+                                >= min_intbc_fraction_for_adding_to_clone_intbc_set
+                            )
+                        )
+                        and counts
+                        >= min_intbc_counts_for_adding_intbc_to_clone_intbc_set
+                    ):
+                        kept_intbcs.append(intbc)
+        clone_intbc_sets[clone_idx] = set(kept_intbcs)
+
+    # At this point, we have our clone intBC sets! It's time to compute the
+    # cell intBC sets (simply by intersection)
+    observed_cell_intbc_sets = cell_intbc_sets
+    cell_intbc_sets = {}
+    for cell, clones in tqdm.tqdm(clone_mapping.items()):
+        observed = observed_cell_intbc_sets[cell]
+        if len(clones) != 1:
+            # We did not confidently map the cell, so we just drop all intBCs
+            cell_intbc_set = set()
+        else:
+            clone_idx = list(clones)[0]
+            clone_intbc_set = clone_intbc_sets[clone_idx]
+            cell_intbc_set = observed.intersection(clone_intbc_set)
+        cell_intbc_sets[cell] = cell_intbc_set
+
+    cell_to_clones_mapping = {
+        x: set(["clone_" + str(y) for y in ys]) for (x, ys) in clone_mapping.items()
+    }
+    for cellbc in all_cellbc:
+        if cellbc not in cell_to_clones_mapping:
+            cell_to_clones_mapping[cellbc] = (
+                set()
+            )  # These lost all their intBCs due to low UMI counts
+        if cellbc not in cell_intbc_sets:
+            cell_intbc_sets[cellbc] = (
+                set()
+            )  # These lost all their intBCs due to low UMI counts
+    clone_intbc_sets = {("clone_" + str(x)): y for (x, y) in clone_intbc_sets.items()}
+    clone_to_cells_mapping = {
+        ("clone_" + str(x)): y for (x, y) in clone_to_cells_mapping.items()
+    }
+
+    clone_call = CloneCallType(
+        clone_to_cells_mapping=clone_to_cells_mapping,
+        cell_to_clones_mapping=cell_to_clones_mapping,
+        clone_intbc_sets=clone_intbc_sets,
+        cell_intbc_sets=cell_intbc_sets,
+    )
+
+    total_time = time.time() - st
+    res = CallClonesFromCoresetsReturnType(
+        clone_call=clone_call,
+        total_time=total_time,
+    )
+    return res
+
+
+def test_call_clones_from_coresets():
+    intbc_table = pd.DataFrame(
+        [
+            ["c1", "A", 5],
+            ["c1", "B", 5],
+            ["c2", "C", 5],
+        ],
+        columns=["cellBC", "intBC", "UMI_count"],
+    )
+    out = call_clones_from_coresets(
+        intbc_table_per_sample={"s0": intbc_table},
+        min_intbc_umi_count=1,
+        coresets=[{"A", "B"}, {"C"}],
+        min_overlap_for_assigning_cellbc=1,
+        min_intbc_counts_for_adding_intbc_to_clone_intbc_set=1,
+        min_intbc_fraction_for_adding_to_clone_intbc_set=0.0,
+        edit_distance_cutoff=0,
+        custom_intbc_filtering_function=lambda intbc: False,
+    )
+    assert out.total_time >= 0.0
+    cc = out.clone_call
+    c1, c2 = "s0_c1", "s0_c2"
+    assert cc.clone_to_cells_mapping["clone_0"] == {c1}
+    assert cc.clone_to_cells_mapping["clone_1"] == {c2}
+    assert cc.clone_intbc_sets["clone_0"] == {"A", "B"}
+    assert cc.clone_intbc_sets["clone_1"] == {"C"}
+    assert cc.cell_intbc_sets[c1] == {"A", "B"}
+    assert cc.cell_intbc_sets[c2] == {"C"}

nova_clone/algorithm/_clone_call_ops.py

@@ -0,0 +1,258 @@
+"""
+Operations for e.g. merging clones, dropping clones, in a clone call.
+"""
+import typing as t
+from ._types import CloneCallType
+from copy import deepcopy
+from collections import defaultdict
+
+
+def merge_clones(
+    clones: t.List[str],
+    clone_call: CloneCallType,
+    new_clone_name: str,
+) -> CloneCallType:
+    """
+    Merge the given clones into one.
+
+    clone_to_cells_mapping: Dict[CloneType, Set[CellBCType]]
+        => we replace the clones by a new key with union of cells.
+    cell_to_clones_mapping: Dict[CellBCType, Set[CloneType]]
+        => we collapse the merged clones into one. To be conservative, multiplets contained in exclusively the `clones` become unmapped cells.
+    clone_intbc_sets: Dict[CloneType, Set[IntBCType]]
+        => we take the union.
+    cell_intbc_sets: Dict[CellBCType, Set[IntBCType]]
+        => Multiplets contained in exclusively the `clones` have their intBC sets cleared.
+    """
+    clone_to_cells_mapping = deepcopy(clone_call.clone_to_cells_mapping)
+    cell_to_clones_mapping = deepcopy(clone_call.cell_to_clones_mapping)
+    clone_intbc_sets = deepcopy(clone_call.clone_intbc_sets)
+    cell_intbc_sets = deepcopy(clone_call.cell_intbc_sets)
+    new_clone_to_cells_mapping = defaultdict(set)
+    new_cell_to_clones_mapping = {}
+    new_clone_intbc_sets = defaultdict(set)
+    new_cell_intbc_sets = {}
+    clones_set = set(clones)
+    for clone in clone_to_cells_mapping:
+        if clone not in clones:
+            new_clone_to_cells_mapping[clone] = clone_to_cells_mapping[clone]
+        else:
+            new_clone_to_cells_mapping[new_clone_name] = new_clone_to_cells_mapping[new_clone_name].union(
+                clone_to_cells_mapping[clone]
+            )
+    for cell in cell_to_clones_mapping:
+        cell_clones = cell_to_clones_mapping[cell]
+        new_cell_clones = set()
+        if len(cell_clones) >= 2 and all(clone in clones_set for clone in cell_clones):
+            # This is a multiplet that mapped only to the merged clones.
+            # We unmap it to be safe, i.e. we leave `new_cell_clones` empty.
+            pass
+        else:
+            for clone in cell_clones:
+                if clone in clones_set:
+                    new_cell_clones.add(new_clone_name)
+                else:
+                    new_cell_clones.add(clone)
+        new_cell_to_clones_mapping[cell] = new_cell_clones
+    for clone in clone_intbc_sets:
+        intbcs = clone_intbc_sets[clone]
+        if clone not in clones_set:
+            new_clone_intbc_sets[clone] = intbcs
+        else:
+            new_clone_intbc_sets[new_clone_name] = new_clone_intbc_sets[new_clone_name].union(intbcs)
+    new_cell_intbc_sets = cell_intbc_sets
+    for cell in new_cell_intbc_sets:
+        if len(new_cell_to_clones_mapping[cell]) == 0:
+            new_cell_intbc_sets[cell] = set()
+    return CloneCallType(  # NOTE: We cast to dict to avoid returning defaultdict
+        clone_to_cells_mapping=dict(new_clone_to_cells_mapping),
+        cell_to_clones_mapping=dict(new_cell_to_clones_mapping),
+        clone_intbc_sets=dict(new_clone_intbc_sets),
+        cell_intbc_sets=dict(new_cell_intbc_sets),
+    )
+
+
+
+def _get_test_clone_call():
+    clone_call = CloneCallType(
+        clone_to_cells_mapping={
+            "clone_1": {"cell_1", "cell_2", "cell_3"},
+            "clone_2": {"cell_4", "cell_5", "cell_6"},
+            "clone_3": {"cell_7", "cell_8"},
+            "clone_4": {"cell_10"},
+        },
+        cell_to_clones_mapping={
+            "cell_1": {"clone_1"},
+            "cell_2": {"clone_1"},
+            "cell_3": {"clone_1"},
+            "cell_4": {"clone_2"},
+            "cell_5": {"clone_2"},
+            "cell_6": {"clone_2"},
+            "cell_7": {"clone_3"},
+            "cell_8": {"clone_3"},
+            "cell_9": {"clone_2", "clone_3"},
+            "cell_10": {"clone_4"},
+            "cell_11": set(),
+            "cell_12": {"clone_1", "clone_4"}
+        },
+        clone_intbc_sets={
+            "clone_1": {"A", "B"},
+            "clone_2": {"C", "D"},
+            "clone_3": {"E", "F"},
+            "clone_4": {"F", "G"},
+        },
+        cell_intbc_sets={
+            "cell_1": {"A", "B"},
+            "cell_2": {"A", "B"},
+            "cell_3": {"A", "B"},
+            "cell_4": {"C", "D"},
+            "cell_5": {"C", "D"},
+            "cell_6": {"C", "D"},
+            "cell_7": {"E", "F"},
+            "cell_8": {"E", "F"},
+            "cell_9": {},
+            "cell_10": {"F", "G"},
+            "cell_11": set(),
+            "cell_12": {"A", "B", "F", "G"},
+        }
+    )
+    return clone_call
+
+
+def test_merge_clones():
+    clone_call = _get_test_clone_call()
+    clone_call = merge_clones(
+        clones=["clone_2", "clone_3", "clone_4"],
+        clone_call=clone_call,
+        new_clone_name="clone_2_3_4"
+    )
+    assert clone_call.clone_to_cells_mapping == {
+        "clone_1": {"cell_1", "cell_2", "cell_3"},
+        "clone_2_3_4": {"cell_4", "cell_5", "cell_6", "cell_7", "cell_8", "cell_10"},
+    }
+    assert clone_call.cell_to_clones_mapping == {
+        "cell_1": {"clone_1"},
+        "cell_2": {"clone_1"},
+        "cell_3": {"clone_1"},
+        "cell_4": {"clone_2_3_4"},
+        "cell_5": {"clone_2_3_4"},
+        "cell_6": {"clone_2_3_4"},
+        "cell_7": {"clone_2_3_4"},
+        "cell_8": {"clone_2_3_4"},
+        "cell_9": set(),
+        "cell_10": {"clone_2_3_4"},
+        "cell_11": set(),
+        "cell_12": {"clone_1", "clone_2_3_4"},
+    }
+    assert clone_call.clone_intbc_sets == {
+        "clone_1": {"A", "B"},
+        "clone_2_3_4": {"C", "D", "E", "F", "G"},
+    }
+    assert clone_call.cell_intbc_sets == {
+        "cell_1": {"A", "B"},
+        "cell_2": {"A", "B"},
+        "cell_3": {"A", "B"},
+        "cell_4": {"C", "D"},
+        "cell_5": {"C", "D"},
+        "cell_6": {"C", "D"},
+        "cell_7": {"E", "F"},
+        "cell_8": {"E", "F"},
+        "cell_9": set(),
+        "cell_10": {"F", "G"},
+        "cell_11": set(),
+        "cell_12": {"A", "B", "F", "G"},
+    }
+
+
+def drop_clones(
+    clones: t.List[str],
+    clone_call: CloneCallType
+) -> CloneCallType:
+    """
+    Drop the given clones.
+
+    clone_to_cells_mapping: Dict[CloneType, Set[CellBCType]]
+        => we drop the clones from here.
+    cell_to_clones_mapping: Dict[CellBCType, Set[CloneType]]
+        => We unmap every cell which maps to *any* of the dropped clones.
+    clone_intbc_sets: Dict[CloneType, Set[IntBCType]]
+        => we drop the clones from here
+    cell_intbc_sets: Dict[CellBCType, Set[IntBCType]]
+        => we clear the intBC set of every cell that we unmapped
+    """
+    clone_to_cells_mapping = deepcopy(clone_call.clone_to_cells_mapping)
+    cell_to_clones_mapping = deepcopy(clone_call.cell_to_clones_mapping)
+    clone_intbc_sets = deepcopy(clone_call.clone_intbc_sets)
+    cell_intbc_sets = deepcopy(clone_call.cell_intbc_sets)
+    new_clone_to_cells_mapping = defaultdict(set)
+    new_cell_to_clones_mapping = {}
+    new_clone_intbc_sets = defaultdict(set)
+    new_cell_intbc_sets = {}
+    clones_set = set(clones)
+    for clone in clone_to_cells_mapping:
+        if clone not in clones:
+            new_clone_to_cells_mapping[clone] = clone_to_cells_mapping[clone]
+    for cell in cell_to_clones_mapping:
+        cell_clones = cell_to_clones_mapping[cell]
+        new_cell_clones = set()
+        if any([clone in clones_set for clone in cell_clones]):
+            new_cell_to_clones_mapping[cell] = set()
+        else:
+            new_cell_to_clones_mapping[cell] = cell_clones
+    for clone in clone_intbc_sets:
+        intbcs = clone_intbc_sets[clone]
+        if clone not in clones:
+            new_clone_intbc_sets[clone] = intbcs
+    for cell in cell_intbc_sets:
+        if len(new_cell_to_clones_mapping[cell]) == 0:
+            new_cell_intbc_sets[cell] = set()
+        else:
+            new_cell_intbc_sets[cell] = cell_intbc_sets[cell]
+    return CloneCallType(  # NOTE: We cast to dict to avoid returning defaultdict
+        clone_to_cells_mapping=dict(new_clone_to_cells_mapping),
+        cell_to_clones_mapping=dict(new_cell_to_clones_mapping),
+        clone_intbc_sets=dict(new_clone_intbc_sets),
+        cell_intbc_sets=dict(new_cell_intbc_sets),
+    )
+
+
+def test_drop_clones():
+    clone_call = _get_test_clone_call()
+    clone_call = drop_clones(
+        clones=["clone_2", "clone_3", "clone_4"],
+        clone_call=clone_call,
+    )
+    assert clone_call.clone_to_cells_mapping == {
+        "clone_1": {"cell_1", "cell_2", "cell_3"},
+    }
+    assert clone_call.cell_to_clones_mapping == {
+        "cell_1": {"clone_1"},
+        "cell_2": {"clone_1"},
+        "cell_3": {"clone_1"},
+        "cell_4": set(),
+        "cell_5": set(),
+        "cell_6": set(),
+        "cell_7": set(),
+        "cell_8": set(),
+        "cell_9": set(),
+        "cell_10": set(),
+        "cell_11": set(),
+        "cell_12": set(),
+    }
+    assert clone_call.clone_intbc_sets == {
+        "clone_1": {"A", "B"},
+    }
+    assert clone_call.cell_intbc_sets == {
+        "cell_1": {"A", "B"},
+        "cell_2": {"A", "B"},
+        "cell_3": {"A", "B"},
+        "cell_4": set(),
+        "cell_5": set(),
+        "cell_6": set(),
+        "cell_7": set(),
+        "cell_8": set(),
+        "cell_9": set(),
+        "cell_10": set(),
+        "cell_11": set(),
+        "cell_12": set(),
+    }