cpg2py 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

cpg2py/abc/__init__.py

@@ -0,0 +1,6 @@
+from .graph import AbcGraphQuerier
+from .node import AbcNodeQuerier
+from .edge import AbcEdgeQuerier
+from .storage import Storage
+
+__all__ = ["Storage", "AbcGraphQuerier", "AbcNodeQuerier", "AbcEdgeQuerier"]

cpg2py/abc/edge.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+import abc
+from .storage import Storage
+from typing import Any, Dict, Optional, Tuple
+
+class AbcEdgeQuerier(abc.ABC): 
+    
+    def __init__(self, graph: Storage, f_nid: str, t_nid: str, e_type: int = 0) -> None:
+        self.__graph: Storage = graph
+        self.__edge_id: Tuple[str, str, str] = (str(f_nid), str(t_nid), str(e_type))
+        if not graph.contains_edge(self.__edge_id): 
+            raise Exception('CANNOT FIND THE NODE ID {nid} IN GRAPH')
+        return None
+
+    @property
+    def edge_id(self) -> Tuple[str, str, int]:
+        return self.__edge_id
+    
+    @property
+    def from_nid(self) -> str: 
+        return self.__edge_id[0]
+
+    @property
+    def to_nid(self) -> str:
+        return self.__edge_id[1]
+    
+    @property
+    def edge_type(self) -> str: 
+        return self.__edge_id[0]
+    
+    @property
+    def properties(self) -> Optional[Dict[str, Any]]: 
+        return self.__graph.get_edge_props(self.__edge_id)
+    
+    def get_property(self, *prop_names: str) -> Optional[Any]: 
+        prop_values = (self.__graph.get_edge_prop(self.__edge_id, p_name) for p_name in prop_names)
+        return next((value for value in prop_values if value is not None), None)
+
+pass

cpg2py/abc/graph.py

@@ -0,0 +1,98 @@
+
+from __future__ import annotations
+
+from .edge import AbcEdgeQuerier
+from .node import AbcNodeQuerier
+
+from typing import Callable, Deque, List, Optional, Iterable
+from collections import deque
+from .storage import Storage
+import abc
+
+class AbcGraphQuerier(abc.ABC): 
+
+    __NodeCondition = Callable[[AbcNodeQuerier], bool]
+    __EdgeCondition = Callable[[AbcEdgeQuerier], bool]
+    __always_true = lambda _: True
+
+    __NodesResult = Iterable[AbcNodeQuerier]
+    __EdgesResult = Iterable[AbcEdgeQuerier]
+
+    def __init__(self, target: Storage, maxdepth: int=-1) -> None:
+        self.__graph: Storage = target
+        self.__maxdepth: int = maxdepth
+
+    @property
+    def storage(self) -> Storage: 
+        return self.__graph
+
+    @abc.abstractmethod
+    def node(self, whose_id_is: str) -> Optional[AbcNodeQuerier]: 
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def edge(self, fid, tid, eid) -> Optional[AbcEdgeQuerier]: 
+        raise NotImplementedError
+
+    def nodes(self, who_satisifies: __NodeCondition=__always_true)-> __NodesResult: 
+        for nid in self.__graph.get_nodes(): 
+            cur_node = self.node(whose_id_is=nid)
+            if cur_node and who_satisifies(cur_node): yield cur_node 
+        pass
+    
+    def first_node(self, who_satisifies: __NodeCondition=__always_true)-> Optional[AbcNodeQuerier]:
+        return next(self.nodes(who_satisifies), None) 
+
+    def edges(self, who_satisifies: __EdgeCondition = __always_true) -> __EdgesResult: 
+        for from_id, to_id, edge_id in self.__graph.get_edges(): 
+            cur_edge = self.edge(from_id, to_id, edge_id)
+            if cur_edge and who_satisifies(cur_edge): yield cur_edge
+        pass 
+
+    def succ(self, of: AbcNodeQuerier, who_satisifies: __EdgeCondition = __always_true) -> __NodesResult: 
+        for src, dst, type in self.__graph.out_edges(of.id):
+            if not who_satisifies(self.edge(src, dst, type)): continue
+            yield self.node(whose_id_is=dst)
+        pass
+
+    def prev(self, of: AbcNodeQuerier, who_satisifies: __EdgeCondition = __always_true) -> __NodesResult: 
+        for src, dst, type in self.__graph.in_edges(of.id):
+            if not who_satisifies(self.edge(src, dst, type)): continue
+            yield self.node(whose_id_is=src)
+        pass
+
+    def __bfs_search(self, root: AbcNodeQuerier, condition: __EdgeCondition, reverse: bool) -> __NodesResult: 
+        '''
+        return the nodes from (any edge relation) src node by the bfs order (src node will not included)
+        '''
+        if root is None: return 
+        visited_nids: List[str] = list()
+        nodes_queue: Deque[AbcNodeQuerier] = deque([root, None])
+        depth = self.__maxdepth
+        while depth != 0 and len(nodes_queue) > 1: 
+            cur_node = nodes_queue.popleft()
+            if cur_node == None: 
+                nodes_queue.append(None)
+                depth -= 1
+            elif cur_node.id not in visited_nids:
+                visited_nids.append(cur_node.id)
+                if not reverse: n_nodes = self.succ(cur_node, condition)
+                else: n_nodes = self.prev(cur_node, condition)
+                nodes_queue.extend(n_nodes)
+                if root.id != cur_node.id: yield cur_node
+        pass
+
+    def descendants(self, src: AbcNodeQuerier, condition: __EdgeCondition = __always_true) -> __NodesResult: 
+        '''
+        return the result of descendants from (any edge relation) src node by the bfs order (src node will not included)
+        '''
+        return self.__bfs_search(src, condition, reverse=False)
+
+    def ancestors(self, src: AbcNodeQuerier, condition: __EdgeCondition = __always_true) -> __NodesResult:
+        '''
+        return the result of ancestors from (any edge relation) src node by the bfs order (src node will not included)
+        '''
+        return self.__bfs_search(src, condition, reverse=True)
+
+pass
+    

cpg2py/abc/node.py

@@ -0,0 +1,26 @@
+from typing import Any, Dict, Optional
+from .storage import Storage
+import abc
+
+class AbcNodeQuerier(abc.ABC):  
+    
+    def __init__(self, graph: Storage, nid: str) -> None:
+        self.__nid: str = str(nid)
+        self.__graph: Storage = graph
+        if not graph.contains_node(self.__nid): 
+            raise Exception(f'CANNOT FIND THE NODE ID {nid} IN GRAPH')
+        return None
+    
+    @property
+    def node_id(self) -> str:
+        return self.__nid
+
+    @property
+    def properties(self) -> Optional[Dict[str, Any]]: 
+        return self.__graph.get_node_props(self.__nid)
+    
+    def get_property(self, *prop_names: str) -> Optional[Any]: 
+        prop_values = (self.__graph.get_node_prop(self.__nid, p_name) for p_name in prop_names)
+        return next((value for value in prop_values if value is not None), None)
+    
+pass

cpg2py/abc/storage.py

@@ -0,0 +1,153 @@
+from typing import Optional, Iterable, Dict, Tuple
+
+
+class Storage:
+    """ A directed multi-graph implementation supporting multiple edges between nodes. """
+
+    __NodeID = str
+    __EdgeID = Tuple[str, str, str]
+    __Property = Dict[str, any]
+
+    def __init__(self):
+        """ Initializes an empty directed graph. """
+        self.__nodes = dict()
+        self.__edges = dict() 
+        self.__struct = dict()
+
+    ################################ GRAPH STRUCTURE APIs ################################
+
+    def add_node(self, nid: __NodeID) -> bool:
+        """ Adds a node to the graph. """
+        nid = str(nid)
+        if nid in self.__nodes: return False
+        self.__nodes[nid] = {}
+        self.__struct[nid] = []
+        return True
+    
+    def contains_node(self, nid: __NodeID) -> bool:
+        """ Checks if a node exists in the graph. """
+        nid = str(nid)
+        return nid in self.__nodes
+
+    def add_edge(self, eid: __EdgeID) -> bool:
+        """ Adds a directed edge from `start` to `end` with an optional edge type. """
+        eid = (str(eid[0]), str(eid[1]), str(eid[2]))
+        if eid in self.__edges: return False
+        if eid[0] not in self.__nodes: return False
+        if eid[1] not in self.__nodes: return False
+        self.__edges[eid] = {}
+        self.__struct[eid[0]].append(eid)
+        self.__struct[eid[1]].append(eid)
+        return True
+    
+    def contains_edge(self, eid: __EdgeID) -> bool:
+        """ Checks if an edge exists in the graph. """
+        eid = (str(eid[0]), str(eid[1]), str(eid[2]))
+        return eid in self.__edges
+    
+    def out_edges(self, nid: __NodeID) -> Iterable[__EdgeID]:
+        """ Returns a list of outgoing edges from a given node. """
+        nid = str(nid)
+        return (eid for eid in self.__struct.get(nid) if eid[0] == nid)
+
+    def in_edges(self, nid: __NodeID) -> Iterable[__EdgeID]:
+        """ Returns a list of incoming edges to a given node. """
+        nid = str(nid)
+        return (eid for eid in self.__struct.get(nid) if eid[1] == nid)
+
+    def successors(self, nid: __NodeID) -> Iterable[__NodeID]:
+        """ Returns all successor nodes of a given node. """
+        nid = str(nid)
+        return (eid[1] for eid in self.__struct.get(nid) if eid[0] == nid)
+
+    def predecessors(self, nid: __NodeID) -> Iterable[__NodeID]:
+        """ Returns all predecessor nodes of a given node. """
+        nid = str(nid)
+        return (eid[0] for eid in self.__struct.get(nid) if eid[1] == nid)
+    
+    ################################ GRAPH PROPERTIES APIs ################################
+
+    def set_node_props(self, node: __NodeID, props: __Property) -> bool:
+        """ Sets the properties of a node. """
+        node = str(node)
+        if node not in self.__nodes: return False
+        prev_data: dict = self.__nodes[node]
+        prev_data.update({str(k) : v for k, v in props.items()})
+        return True
+    
+    def get_node_props(self, node: __NodeID) -> Optional[__Property]:
+        """ Returns the properties of a node. """
+        node = str(node)
+        print(self.__nodes)
+        return self.__nodes.get(node, None)
+    
+    def set_node_prop(self, node: __NodeID, key: str, value: any) -> bool:
+        """ Sets the properties of a node. """
+        node, key = str(node), str(key)
+        if node not in self.__nodes: return False
+        self.__nodes[node][key] = value
+        return True
+    
+    def get_node_prop(self, node: __NodeID, key: str) -> Optional[any]:
+        """ Returns the properties of a node. """
+        node, key = str(node), str(key)
+        return self.__nodes.get(node, {}).get(key, None)
+    
+    def set_edge_props(self, eid: __EdgeID, props: __Property) -> bool:
+        """ Sets the properties of an edge. """
+        eid = (str(eid[0]), str(eid[1]), str(eid[2]))
+        if eid not in self.__edges: return False
+        prev_data: dict = self.__edges[eid]
+        prev_data.update({str(k) : v for k, v in props.items()})
+        return True
+    
+    def get_edge_props(self, eid: __EdgeID) -> Optional[__Property]:
+        """ Returns the properties of an edge. """
+        eid = (str(eid[0]), str(eid[1]), str(eid[2]))
+        return self.__edges.get(eid)
+      
+    def set_edge_prop(self, eid: __EdgeID, key: str, value: any) -> bool:
+        """ Sets the properties of an edge. """
+        eid = (str(eid[0]), str(eid[1]), str(eid[2]))
+        key = str(key)
+        if eid not in self.__edges: return False
+        self.__edges[eid][key] = value
+        return
+    
+    def get_edge_prop(self, eid: __EdgeID, key: str) -> Optional[__Property]:
+        """ Returns the properties of an edge. """
+        eid = (str(eid[0]), str(eid[1]), str(eid[2]))
+        key = str(key)
+        return self.__edges.get(eid, {}).get(key, None)
+
+    def __repr__(self):
+        """ Returns a string representation of the graph. """
+        return f"MultiDiGraph(nodes={len(self.nodes)}, edges={len(self.get_edges())})"
+    
+    ################################ GRAPH COMMON APIs ################################
+
+    def get_nodes(self) -> Iterable[__NodeID]:
+        """ Returns a list of all nodes in the graph. """
+        return self.__nodes.keys()
+
+    def get_edges(self) -> Iterable[__EdgeID]:
+        """ Returns a list of all edges in the graph. """
+        return self.__edges.keys()
+    
+    def remove_node(self, nid: __NodeID) -> bool:
+        """ Removes a node from the graph. """
+        nid = str(nid)
+        if nid not in self.__nodes: return False
+        self.__nodes.pop(nid)
+        for eid in self.__struct[nid]:
+            self.__edges.pop(eid)
+        return True
+    
+    def remove_edge(self, eid: __EdgeID) -> bool:
+        """ Removes an edge from the graph. """
+        eid = (str(eid[0]), str(eid[1]), str(eid[2]))
+        if eid not in self.__edges: return False
+        self.__struct[eid[0]].remove(eid)
+        self.__struct[eid[1]].remove(eid)
+        self.__edges.pop(eid)
+        return True

cpg2py/cpg/__init__.py

@@ -0,0 +1,3 @@
+from .graph import _Graph
+
+__all__ = ['_Graph']

cpg2py/cpg/edge.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+from typing import Optional, Tuple
+from enum import Enum
+from ..abc import AbcGraphQuerier, AbcEdgeQuerier
+
+class _Edge(AbcEdgeQuerier): 
+    
+    def __init__(self, graph: AbcGraphQuerier, f_nid: str, t_nid: str, e_type: str) -> None:
+        super().__init__(graph, f_nid, t_nid, e_type)
+        return None
+    
+    @property
+    def id(self) -> Tuple[str, str, str]: 
+        return self.edge_id
+
+    @property
+    def start(self) -> Optional[int]:
+        start_str = str(self.get_property('start', 'start:START_ID'))
+        return int(start_str) if start_str.isnumeric() else int(self.__from_id)
+
+    @property
+    def end(self) -> Optional[int]: 
+        end_str = str(self.get_property('end', 'end:END_ID'))
+        return int(end_str) if end_str.isnumeric() else int(self.__to_id) 
+
+    @property
+    def type(self) -> Optional[str]: 
+        return self.get_property('type', 'type:TYPE')
+    
+    @property
+    def var(self) -> Optional[str]: 
+        return self.get_property('var')

cpg2py/cpg/graph.py

@@ -0,0 +1,97 @@
+
+from __future__ import annotations
+
+from .edge import _Edge
+from .node import _Node
+from ..abc import AbcGraphQuerier, Storage 
+
+from typing import Callable, Iterable, Optional
+import json, functools
+
+class _Graph(AbcGraphQuerier): 
+    '''
+    OPG is Object Property Diagram used by ODgen and FAST
+    '''
+    __EdgeCondition = Callable[[_Edge], bool]
+    __always_true = lambda _: True
+
+    def __init__(self, target: Storage) -> None:
+        super().__init__(target)
+        return None
+
+    def node(self, whose_id_is: str) -> Optional[_Node]:
+        try: 
+            return _Node(self.storage, whose_id_is)
+        except Exception as e: print(
+            f'✘ {_Graph} ERROR:'
+            f'Cannot find node with id {whose_id_is}.'
+            f'(exception is {e})'
+        )
+        return None
+    
+    def edge(self, fid: str, tid: str, eid:str) -> Optional[_Edge]: 
+        try: 
+            return _Edge(self.storage, fid, tid, eid)
+        except Exception as e: print(
+            f'✘ {_Graph} ERROR:'
+            f'Cannot find edge from {fid} to {tid}, and eid is {str(eid)}.'
+            f'(exception is {e})'
+        )
+        return None
+    
+    @functools.lru_cache()
+    def topfile_node(self, of_nid: str) -> _Node: 
+        '''
+        find the top file node from the input node.
+        '''
+        of_node = self.node(of_nid)
+        if of_node.type == "File": return of_node
+        if 'TOPLEVEL_FILE' in of_node.flags: return of_node
+        parents = self.prev(of_node, lambda e: e.type in ["PARENT_OF", "ENTRY", "EXIT"])
+        for pre in parents: 
+            top_file = self.topfile_node(pre.id)
+            if top_file is not None: return top_file
+        raise Exception(f'❌ INNER ERROR(500): CANNOT FIND THE TOPFILE.')
+    
+    def succ(self, of: _Node, who_satisifies: __EdgeCondition = __always_true) -> Iterable[_Node]: 
+        '''
+        return the next nodes connected with the input one.
+        '''
+        return super().succ(of.id, who_satisifies)
+    
+    def prev(self, of, who_satisifies = __always_true) -> Iterable[_Node]:
+        '''
+        return the previous nodes connected with the input one.
+        '''
+        return super().prev(of, who_satisifies)
+
+
+    def children(self, of: _Node, extra: __EdgeCondition = __always_true) -> Iterable[_Node]: 
+        '''
+        return the next nodes connected with the input one.
+        The edge type between them is PARENT_OF 
+        '''
+        return self.succ(of, lambda e: extra(e) and (e.type == "PARENT_OF"))
+
+    def parent(self, of: _Node, extra:__EdgeCondition = __always_true) -> Iterable[_Node]: 
+        '''
+        return the prev nodes connected with the input one.
+        The edge type between them is PARENT_OF 
+        '''
+        return self.prev(of, lambda e: extra(e) and (e.type == "PARENT_OF"))
+
+    def flow_to(self, of: _Node, extra: __EdgeCondition = __always_true) -> Iterable[_Node]: 
+        '''
+        return the next nodes connected with the input one.
+        The edge type between them is FLOW_TO 
+        '''
+        return self.succ(of, lambda e: extra(e) and (e.type == "FLOWS_TO"))
+
+    def flow_from(self, of: _Node, extra: __EdgeCondition = __always_true) -> Iterable[_Node]:
+        '''
+        return the previous nodes connected with the input one.
+        The edge type between them is FLOW_TO 
+        '''
+        return self.prev(of, lambda e: extra(e) and (e.type == "FLOWS_TO"))
+    
+pass

cpg2py/cpg/node.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+from typing import List, Optional
+
+from ..abc import AbcNodeQuerier, AbcGraphQuerier
+
+class _Node(AbcNodeQuerier):  
+    
+    def __init__(self, graph: AbcGraphQuerier, nid: str) -> None:
+        super().__init__(graph, nid)
+        return None
+    
+    @property
+    def id(self) -> str: return self.node_id
+
+    @property
+    def code(self) -> Optional[str]: 
+        return self.get_property('code')
+    
+    @property
+    def label(self) -> Optional[str]: 
+        return self.get_property('labels:label', 'labels')
+    
+    @property
+    def flags(self) -> List[str]: 
+        flags_str = self.get_property('flags:string_array', 'flags:string[]', 'flags')
+        return str(flags_str).split(' ') if flags_str is not None else []
+    
+    @property
+    def line_num(self) -> Optional[int]: 
+        linenum_str = str(self.get_property('lineno:int', 'lineno'))
+        return int(linenum_str) if linenum_str.isnumeric() else None
+    
+    @property
+    def children_num(self) -> Optional[int]: 
+        num_str = str(self.get_property('childnum:int', 'childnum'))
+        return int(num_str) if num_str.isnumeric() else None
+
+    @property
+    def func_id(self) -> Optional[int]: 
+        fid_str = str(self.get_property('funcid:int', 'funcid'))
+        return int(fid_str) if fid_str.isnumeric() else None
+    
+    @property
+    def class_name(self) -> Optional[str]: 
+        return self.get_property('classname')
+
+    @property
+    def namespace(self) -> Optional[str]: 
+        return self.get_property('namespace')
+        
+    @property
+    def name(self) -> Optional[str]: return self.get_property('name')
+
+    @property
+    def end_num(self) -> Optional[int]:
+        end_str = str(self.get_property('endlineno:int', 'endlineno'))
+        return int(end_str) if end_str.isnumeric() else None
+
+    @property
+    def comment(self) -> Optional[str]: 
+        return self.get_property('doccomment')
+
+    @property 
+    def type(self) -> Optional[str]: 
+        return self.get_property('type')

{cpg2py-1.0.0.dist-info → cpg2py-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cpg2py
-Version: 1.0.0
+Version: 1.0.2
 Summary: A graph-based data structure designed for querying CSV files in Joern format in Python
 Home-page: https://github.com/YichaoXu/cpg2py
 Author: Yichao Xu

cpg2py-1.0.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+cpg2py/__init__.py,sha256=bjd1EjYmNa0N8DW4tSQg-YpzzkqgtBVR2FrgDZReY10,1557
+cpg2py/abc/__init__.py,sha256=HgDXsJkGcPQvr6ac3hMrUU9TuQibMaP7-oXbXLs_iLI,207
+cpg2py/abc/edge.py,sha256=zLlRebDKT2qK5XOJq23_UUCESgGsvgalbXdx_uUcKks,1240
+cpg2py/abc/graph.py,sha256=DbeHN6qsNaqcqL9cUquJWC16BihDxy1MEhyuL-qVMBI,3902
+cpg2py/abc/node.py,sha256=E2EQv_KisEPuslFaglZZvSBm-VY5LYCFBOFY1yiPzDY,844
+cpg2py/abc/storage.py,sha256=BF82Vs_7FxGYSPiM_6JwQVzmaqMzGy2r-WSk8pQQclY,5976
+cpg2py/cpg/__init__.py,sha256=fO59Yd7OISyxdjdZDJ5zFM41r4cYKawOsvpqV4gWrGM,48
+cpg2py/cpg/edge.py,sha256=_ERU_lS4_5AxlOiuX73JvTZBSr9o8ae0q-kWwO82580,1029
+cpg2py/cpg/graph.py,sha256=n4EjAhhjzl0XRJBwlAmK5AcSrECiqhjA6dXt2Ucf7IM,3448
+cpg2py/cpg/node.py,sha256=-2xl8c-eSbe4Kv4xPAEf6POlCYOV4j0voxJAKDZj3Cc,2037
+cpg2py-1.0.2.dist-info/LICENSE,sha256=vTjbt7iL1hUilI8E87FoQerEDa9nbpeip26iA6bguHI,1066
+cpg2py-1.0.2.dist-info/METADATA,sha256=dCiQ4H2zcFC9AfFVOsSAkzFJDsKccGwcuyGYCnj9LRs,7077
+cpg2py-1.0.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+cpg2py-1.0.2.dist-info/top_level.txt,sha256=xDY8faKh5Rczvsqb5Jt9Sq-Y7EOImh7jh-m1oVTnH5k,7
+cpg2py-1.0.2.dist-info/RECORD,,

cpg2py-1.0.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-cpg2py/__init__.py,sha256=bjd1EjYmNa0N8DW4tSQg-YpzzkqgtBVR2FrgDZReY10,1557
-cpg2py-1.0.0.dist-info/LICENSE,sha256=vTjbt7iL1hUilI8E87FoQerEDa9nbpeip26iA6bguHI,1066
-cpg2py-1.0.0.dist-info/METADATA,sha256=ESCorHBwLXChyZNEH5MdekKZiD59VFc1g6IYs8-YsfM,7077
-cpg2py-1.0.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-cpg2py-1.0.0.dist-info/top_level.txt,sha256=xDY8faKh5Rczvsqb5Jt9Sq-Y7EOImh7jh-m1oVTnH5k,7
-cpg2py-1.0.0.dist-info/RECORD,,