cpg2py 1.0.5__py3-none-any.whl → 1.2.0__py3-none-any.whl

cpg2py-1.2.0.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: cpg2py
+Version: 1.2.0
+Summary: A graph-based data structure designed for querying CSV files in Joern format in Python
+Author-email: samhsu-dev <yxu166@jhu.edu>
+License: MIT License
+        
+        Copyright (c) 2025 samhsu-dev
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/samhsu-dev/cpg2py
+Project-URL: Repository, https://github.com/samhsu-dev/cpg2py
+Project-URL: Documentation, https://github.com/samhsu-dev/cpg2py
+Keywords: Joern,CPG,Graph,CSV
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7.4.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: pylint>=2.17.0; extra == "dev"
+Dynamic: license-file
+
+# cpg2py
+
+Python graph query engine for Code Property Graphs from Joern CSV exports. Directed multi-graph with generic ABCs for custom node/edge/graph types.
+
+**Features**: Load from `nodes.csv` + `rels.csv`; query/update nodes and edges (`get_property`, `set_property`, `set_properties`); traverse succ/prev/children/parent/flow_to/flow_from; JSON persistence (`save_json`, `load_json`, `storage_from_json`). Concrete types: `CpgGraph`, `CpgNode`, `CpgEdge`.
+
+---
+
+## Installation
+
+```bash
+pip install cpg2py
+```
+
+From source (e.g. with [uv](https://github.com/astral-sh/uv)):
+
+```bash
+git clone https://github.com/samhsu-dev/cpg2py.git && cd cpg2py
+uv sync --dev
+uv run pytest tests/
+```
+
+---
+
+## Input format
+
+- **nodes.csv**: tab-delimited; must include node id (e.g. `id:int` or `id`). Other columns become node properties.
+- **rels.csv**: tab-delimited; columns `start`, `end`, `type` (or `start:str`, `end:str`, `type:str`).
+
+---
+
+## Usage
+
+**Load from CSV**
+
+```python
+from pathlib import Path
+from cpg2py import cpg_graph, CpgGraph, CpgNode, CpgEdge
+
+graph: CpgGraph = cpg_graph(Path("nodes.csv"), Path("rels.csv"))
+```
+
+**Nodes and edges** (edge identified by `(from_id, to_id, edge_type)`; `edge_type` is string)
+
+```python
+node: CpgNode = graph.node("2")
+node.name
+node.set_property("name", "x")
+node.set_properties({"k": "v"})
+
+edge: CpgEdge = graph.edge("2", "3", "ENTRY")
+edge.from_nid, edge.to_nid, edge.type
+edge.set_property("weight", 0.5)
+```
+
+**Traversal**
+
+```python
+graph.succ(node)   # successors
+graph.prev(node)   # predecessors
+graph.children(node)
+graph.parent(node)
+graph.flow_to(node)
+graph.flow_from(node)
+graph.topfile_node("5")   # top-level file node for given node ID
+```
+
+**Filtered iteration** (optional predicate)
+
+```python
+graph.nodes(lambda n: n.type == "Function")
+graph.edges(lambda e: e.edge_type == "FLOWS_TO")
+graph.succ(node, who_satisifies=lambda e: e.edge_type == "PARENT_OF")
+graph.descendants(node, condition=...)
+graph.ancestors(node, condition=...)
+```
+
+**JSON persistence**
+
+```python
+graph.storage.save_json("graph.json")
+
+storage = Storage()
+storage.load_json("graph.json")
+graph2 = CpgGraph(storage)
+
+# or
+storage = storage_from_json(Path("graph.json"))
+```
+
+JSON schema: `{"nodes": { "<id>": { "<key>": <value>, ... }, ... }, "edges": [ {"from": str, "to": str, "type": str, "props": {...} }, ... ]}`. See [design.md](docs/design.md).
+
+---
+
+## Extending (ABCs)
+
+Implement `AbcGraphQuerier[MyNode, MyEdge]`, `AbcNodeQuerier`, `AbcEdgeQuerier`; inject `Storage`. Full interface and contracts: [docs/design.md](docs/design.md).
+
+Minimal custom graph:
+
+```python
+from cpg2py import AbcGraphQuerier, AbcNodeQuerier, AbcEdgeQuerier, Storage
+from typing import Optional
+
+class MyNode(AbcNodeQuerier): pass
+class MyEdge(AbcEdgeQuerier): pass
+
+class MyGraph(AbcGraphQuerier[MyNode, MyEdge]):
+    def node(self, whose_id_is: str) -> Optional[MyNode]:
+        return MyNode(self.storage, whose_id_is)
+    def edge(self, fid: str, tid: str, eid: str) -> Optional[MyEdge]:
+        return MyEdge(self.storage, fid, tid, eid)
+
+g = MyGraph(Storage())
+```
+
+---
+
+Interface specifications (classes, methods, signatures, validation): [docs/design.md](docs/design.md).
+
+---
+
+## License
+MIT.

cpg2py-1.2.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+cpg2py/__init__.py,sha256=j_4bRx0t-P10QnOXahQ89avNJne_1mVio0Gd62JIRLs,3548
+cpg2py/_exceptions.py,sha256=OlnptpATmuzRQS0HoC24MoDPcPrY01uGMhVPJdK7Zuo,1376
+cpg2py/_logger.py,sha256=HjJAhs4ZAB_IMoBMVRe3KPGS5GRygGy0eNncvIqu8ls,1309
+cpg2py/_abc/__init__.py,sha256=XN7RKxMpnZqvjDAUWxXXLGKY1jrPpKBAxUbq-pydwh4,208
+cpg2py/_abc/edge.py,sha256=Co3TXbfR2kd7G5oXFVEO0YjDND0zzFecf_R6yRHcyzw,2956
+cpg2py/_abc/graph.py,sha256=LDF2ylbJYQubUV2LboJlkiQaqWtLW3LsyKBkTJOl4Gs,7795
+cpg2py/_abc/node.py,sha256=ZnMf0TTi2Pv69AhzmomI8a8z8_05WgzVpK9p8VisTr8,2275
+cpg2py/_abc/storage.py,sha256=E8lB6uo4zMCvgFmg6LJ5x00AoAFT-gha8nY3FxcJAQE,9252
+cpg2py/_cpg/__init__.py,sha256=BYNrxYo0G3XoIaUN9llEYkZoCstYJgt88OrJZCkQW7E,126
+cpg2py/_cpg/edge.py,sha256=bqzv9dmAVMFSyDmyCLhE0SKIWZZ9gu9UWLC3j6dfhAQ,886
+cpg2py/_cpg/graph.py,sha256=Aks2VsDolKdT1NdEz9Vn5ABIWBTPDGvEq7PbrehLVuI,5674
+cpg2py/_cpg/node.py,sha256=wSBCTCvA8UWQZG9CJn0QyBlQPt9PiXlPd0B2Ddlr7BI,1945
+cpg2py-1.2.0.dist-info/licenses/LICENSE,sha256=ZAjdPt8K7uO5xDb4RyEuUTNZtFGx9_sfSQCy0OP64cU,1067
+cpg2py-1.2.0.dist-info/METADATA,sha256=a-sNUByG1k8a0xX_HFQKRmINP8LDcJ9FMuz5RcqjzNU,5915
+cpg2py-1.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cpg2py-1.2.0.dist-info/top_level.txt,sha256=xDY8faKh5Rczvsqb5Jt9Sq-Y7EOImh7jh-m1oVTnH5k,7
+cpg2py-1.2.0.dist-info/RECORD,,

{cpg2py-1.0.5.dist-info → cpg2py-1.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{cpg2py-1.0.5.dist-info → cpg2py-1.2.0.dist-info/licenses}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Yichao Xu
+Copyright (c) 2025 samhsu-dev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

cpg2py/abc/edge.py

@@ -1,39 +0,0 @@
-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

@@ -1,98 +0,0 @@
-
-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

@@ -1,26 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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

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

cpg2py/cpg/edge.py

@@ -1,31 +0,0 @@
-from __future__ import annotations
-from typing import Optional, Tuple
-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

@@ -1,97 +0,0 @@
-
-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