Skip to content

IndexMap

IndexMap

Maps node indices to string ids

Source code in src/pathpyG/core/IndexMap.py 
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
class IndexMap:
    """Maps node indices to string ids"""
    def __init__(self, node_ids: Union[List[str], None] = None) -> None:
        """Initialize mapping from indices to node IDs."""
        if node_ids is not None:
            assert len(node_ids) == len(set(node_ids)), "node_id entries must be unique"
            # first-order: nodes = integer indices
            self.node_ids: np.ndarray = np.array(node_ids)
            self.id_to_idx: Dict[str, int] = {v: i for i, v in enumerate(node_ids)}
            self.has_ids = True
        else:
            self.node_ids = np.array([])
            self.id_to_idx = {}
            self.has_ids = False

    def num_ids(self) -> int:
        return len(self.node_ids)

    def add_id(self, node_id: str) -> None:
        """Assigns additional ID to next consecutive index."""
        if node_id not in self.id_to_idx:
            idx = self.num_ids()
            self.node_ids = np.append(self.node_ids, node_id)
            self.id_to_idx[node_id] = idx
            self.has_ids = True

    def add_ids(self, node_ids: list | np.ndarray) -> None:
        """Assigns additional IDs to next consecutive indices."""
        cur_num_ids = self.num_ids()
        node_ids = np.array(node_ids)
        mask = np.isin(node_ids, self.node_ids)
        new_ids = np.unique(node_ids[~mask])
        self.node_ids = np.append(self.node_ids, new_ids)
        self.id_to_idx.update({v: i + cur_num_ids for i, v in enumerate(new_ids)})
        self.has_ids = True

    def to_id(self, idx: int) -> Union[int, str, tuple]:
        """Map index to ID if mapping is defined, return index otherwise."""
        if self.has_ids:
            if self.node_ids.ndim == 1:
                return self.node_ids[idx]
            else:
                return tuple(self.node_ids[idx])
        else:
            return idx

    def to_ids(self, idxs: list | tuple) -> list:
        """Map list of indices to IDs if mapping is defined, return indices otherwise."""
        if self.has_ids:
            return self.node_ids[idxs].tolist()
        else:
            return idxs

    def to_idx(self, node: Union[str, int]) -> int:
        """Map argument (ID or index) to index if mapping is defined, return argument otherwise."""
        if self.has_ids:
            return self.id_to_idx[node]
        else:
            return node

    def to_idxs(self, nodes: list | tuple) -> torch.Tensor:
        """Map list of arguments (IDs or indices) to indices if mapping is defined, return argument otherwise."""
        if self.has_ids:
            return torch.tensor([self.id_to_idx[node] for node in nodes])
        else:
            return torch.tensor(nodes)

    def __str__(self) -> str:
        s = ''
        for v in self.id_to_idx:
            s += str(v) + ' -> ' + str(self.to_idx(v)) + '\n'
        return s

__init__

Initialize mapping from indices to node IDs.

Source code in src/pathpyG/core/IndexMap.py 
10
11
12
13
14
15
16
17
18
19
20
21
def __init__(self, node_ids: Union[List[str], None] = None) -> None:
    """Initialize mapping from indices to node IDs."""
    if node_ids is not None:
        assert len(node_ids) == len(set(node_ids)), "node_id entries must be unique"
        # first-order: nodes = integer indices
        self.node_ids: np.ndarray = np.array(node_ids)
        self.id_to_idx: Dict[str, int] = {v: i for i, v in enumerate(node_ids)}
        self.has_ids = True
    else:
        self.node_ids = np.array([])
        self.id_to_idx = {}
        self.has_ids = False

add_id

Assigns additional ID to next consecutive index.

Source code in src/pathpyG/core/IndexMap.py 
26
27
28
29
30
31
32
def add_id(self, node_id: str) -> None:
    """Assigns additional ID to next consecutive index."""
    if node_id not in self.id_to_idx:
        idx = self.num_ids()
        self.node_ids = np.append(self.node_ids, node_id)
        self.id_to_idx[node_id] = idx
        self.has_ids = True

add_ids

Assigns additional IDs to next consecutive indices.

Source code in src/pathpyG/core/IndexMap.py 
34
35
36
37
38
39
40
41
42
def add_ids(self, node_ids: list | np.ndarray) -> None:
    """Assigns additional IDs to next consecutive indices."""
    cur_num_ids = self.num_ids()
    node_ids = np.array(node_ids)
    mask = np.isin(node_ids, self.node_ids)
    new_ids = np.unique(node_ids[~mask])
    self.node_ids = np.append(self.node_ids, new_ids)
    self.id_to_idx.update({v: i + cur_num_ids for i, v in enumerate(new_ids)})
    self.has_ids = True

to_id

Map index to ID if mapping is defined, return index otherwise.

Source code in src/pathpyG/core/IndexMap.py 
44
45
46
47
48
49
50
51
52
def to_id(self, idx: int) -> Union[int, str, tuple]:
    """Map index to ID if mapping is defined, return index otherwise."""
    if self.has_ids:
        if self.node_ids.ndim == 1:
            return self.node_ids[idx]
        else:
            return tuple(self.node_ids[idx])
    else:
        return idx

to_ids

Map list of indices to IDs if mapping is defined, return indices otherwise.

Source code in src/pathpyG/core/IndexMap.py 
54
55
56
57
58
59
def to_ids(self, idxs: list | tuple) -> list:
    """Map list of indices to IDs if mapping is defined, return indices otherwise."""
    if self.has_ids:
        return self.node_ids[idxs].tolist()
    else:
        return idxs

to_idx

Map argument (ID or index) to index if mapping is defined, return argument otherwise.

Source code in src/pathpyG/core/IndexMap.py 
61
62
63
64
65
66
def to_idx(self, node: Union[str, int]) -> int:
    """Map argument (ID or index) to index if mapping is defined, return argument otherwise."""
    if self.has_ids:
        return self.id_to_idx[node]
    else:
        return node

to_idxs

Map list of arguments (IDs or indices) to indices if mapping is defined, return argument otherwise.

Source code in src/pathpyG/core/IndexMap.py 
68
69
70
71
72
73
def to_idxs(self, nodes: list | tuple) -> torch.Tensor:
    """Map list of arguments (IDs or indices) to indices if mapping is defined, return argument otherwise."""
    if self.has_ids:
        return torch.tensor([self.id_to_idx[node] for node in nodes])
    else:
        return torch.tensor(nodes)