codeanalyzer-python 1.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

codeanalyzer/core.py

@@ -163,8 +163,159 @@ class Codeanalyzer:
             stderr=None,
         )
 
+    @classmethod
+    def _get_base_interpreter(cls) -> Path:
+        """The interpreter used to provision the analysis virtualenv.
+
+        jedi parses the *analysis environment's* Python version with parso,
+        which ships one hardcoded grammar file per minor version — an
+        environment newer than the newest shipped grammar makes every file
+        fail with "Python version X.Y is currently not supported" while the
+        run still exits 0 (#107). So the default choice is gated on the
+        installed parso's ceiling: a too-new default is swapped for the
+        newest supported interpreter found on the host, falling back to the
+        default (loudly) only when none exists. An explicit ``SYSTEM_PYTHON``
+        always wins, with a warning when parso cannot parse its version.
+        """
+        # An explicit SYSTEM_PYTHON override wins (consulted only when running
+        # inside a virtualenv, matching the historical behavior).
+        if sys.prefix != sys.base_prefix:
+            system_python = os.getenv("SYSTEM_PYTHON")
+            if system_python:
+                system_python_path = Path(system_python)
+                if system_python_path.exists() and system_python_path.is_file():
+                    ceiling = cls._parso_supported_ceiling()
+                    version = cls._interpreter_version(system_python_path)
+                    if ceiling is not None and version is not None and version > ceiling:
+                        logger.warning(
+                            f"SYSTEM_PYTHON={system_python} is Python "
+                            f"{version[0]}.{version[1]}, newer than the newest grammar "
+                            f"the installed parso ships ({ceiling[0]}.{ceiling[1]}). "
+                            "jedi will likely reject every file in the analysis "
+                            "environment (#107); honoring the explicit override anyway."
+                        )
+                    return system_python_path
+
+        candidate = cls._default_base_interpreter()
+        ceiling = cls._parso_supported_ceiling()
+        if ceiling is None:
+            return candidate
+        version = cls._interpreter_version(candidate)
+        if version is None or version <= ceiling:
+            return candidate
+        logger.warning(
+            f"Default interpreter {candidate} is Python {version[0]}.{version[1]}, "
+            f"newer than the newest grammar the installed parso ships "
+            f"({ceiling[0]}.{ceiling[1]}) — looking for a supported interpreter "
+            "for the analysis environment (#107)."
+        )
+        supported = cls._find_supported_interpreter(ceiling)
+        if supported is not None:
+            logger.info(f"Provisioning the analysis environment with {supported}.")
+            return supported
+        logger.warning(
+            f"No interpreter <= {ceiling[0]}.{ceiling[1]} found on this host; "
+            f"falling back to {candidate}. jedi/parso will likely reject every "
+            "file — install a supported Python or upgrade parso."
+        )
+        return candidate
+
+    @staticmethod
+    def _versions_from_grammar_stems(stems: List[str]) -> List[tuple]:
+        """``grammar313`` → ``(3, 13)``, sorted ascending; malformed stems dropped."""
+        versions = []
+        for stem in stems:
+            digits = stem[len("grammar"):]
+            if len(digits) >= 2 and digits.isdigit():
+                versions.append((int(digits[0]), int(digits[1:])))
+        return sorted(versions)
+
+    @classmethod
+    def _parso_supported_ceiling(cls) -> Optional[tuple]:
+        """Newest ``(major, minor)`` the installed parso ships a grammar for,
+        derived from its ``python/grammar*.txt`` files so the ceiling moves
+        automatically when parso adds a version. ``None`` if undeterminable."""
+        try:
+            import parso
+
+            stems = [
+                p.stem
+                for p in (Path(parso.__file__).parent / "python").glob("grammar*.txt")
+            ]
+            versions = cls._versions_from_grammar_stems(stems)
+            return versions[-1] if versions else None
+        except Exception:
+            return None
+
+    @staticmethod
+    def _interpreter_version(interpreter: Path) -> Optional[tuple]:
+        """``(major, minor)`` of an interpreter, or ``None`` if it can't run."""
+        try:
+            result = subprocess.run(
+                [
+                    str(interpreter),
+                    "-c",
+                    "import sys; print('%d.%d' % sys.version_info[:2])",
+                ],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0:
+                major, minor = result.stdout.strip().split(".")
+                return (int(major), int(minor))
+        except (subprocess.TimeoutExpired, FileNotFoundError, PermissionError, ValueError):
+            pass
+        return None
+
+    @staticmethod
+    def _pick_supported_interpreter(
+        candidates: List[tuple], ceiling: tuple
+    ) -> Optional[Path]:
+        """Newest candidate whose version is within the ceiling.
+
+        ``candidates`` is ``[(path, (major, minor) | None), ...]``."""
+        supported = [
+            (version, path)
+            for path, version in candidates
+            if version is not None and version <= ceiling
+        ]
+        return max(supported)[1] if supported else None
+
+    @classmethod
+    def _find_supported_interpreter(cls, ceiling: tuple) -> Optional[Path]:
+        """Search the host for the newest interpreter within the parso ceiling:
+        versioned names on PATH (``python3.13``, ``python3.12``, ...) first,
+        then pyenv installs."""
+        paths: List[Path] = []
+        for minor in range(ceiling[1], 7, -1):
+            which = shutil.which(f"python{ceiling[0]}.{minor}")
+            # Skip the current virtualenv's own interpreter (same rule as
+            # _default_base_interpreter): the analysis env must come from a
+            # base installation.
+            if which and not which.startswith(sys.prefix):
+                paths.append(Path(which))
+        for pyenv_root in (os.getenv("PYENV_ROOT"), str(Path.home() / ".pyenv")):
+            if not pyenv_root:
+                continue
+            versions_dir = Path(pyenv_root) / "versions"
+            if versions_dir.is_dir():
+                for install in sorted(versions_dir.iterdir(), reverse=True):
+                    exe = install / "bin" / "python3"
+                    if exe.exists():
+                        paths.append(exe)
+        seen = set()
+        candidates = []
+        for path in paths:
+            key = str(path)
+            if key in seen:
+                continue
+            seen.add(key)
+            candidates.append((path, cls._interpreter_version(path)))
+        return cls._pick_supported_interpreter(candidates, ceiling)
+
     @staticmethod
-    def _get_base_interpreter() -> Path:
+    def _default_base_interpreter() -> Path:
         """Get the base Python interpreter path.
 
         This method finds a suitable base Python interpreter that can be used
@@ -183,13 +334,6 @@ class Codeanalyzer:
 
         # We're inside a virtual environment; need to find the base interpreter
 
-        # First, check if user explicitly set SYSTEM_PYTHON
-        system_python = os.getenv("SYSTEM_PYTHON")
-        if system_python:
-            system_python_path = Path(system_python)
-            if system_python_path.exists() and system_python_path.is_file():
-                return system_python_path
-
         # Try to get the base interpreter from sys.base_executable (Python 3.3+)
         if hasattr(sys, "base_executable") and sys.base_executable:
             base_exec = Path(sys.base_executable)
@@ -778,6 +922,15 @@ class Codeanalyzer:
             if files_from_cache > 0:
                 logger.info(f"Reused {files_from_cache} files from cache, processed {files_processed} new/changed files")
 
+        if py_files and not symbol_table:
+            logger.error(
+                "Every one of the %d discovered Python files failed to process — "
+                "the symbol table is empty. This usually means the analysis "
+                "environment's interpreter is newer than the installed jedi/parso "
+                "stack supports (#107); check the per-file errors above.",
+                len(py_files),
+            )
+
         logger.info(
             "✅ Symbol table: %d modules in %.1fs",
             len(symbol_table), time.perf_counter() - t0_st,

codeanalyzer/dataflow/scalpel/README.md

@@ -0,0 +1,34 @@
+# Vendored Scalpel (typed_ast-free slice)
+
+Vendored from **[SMAT-Lab/Scalpel](https://github.com/SMAT-Lab/Scalpel)**,
+package `python-scalpel==1.0b0`, licensed **Apache-2.0** (see `LICENSE`).
+
+## Why vendored
+
+`python-scalpel` hard-depends on `typed_ast`, whose last release (1.5.5) has no
+wheel for Python 3.12+ and fails to build from source on modern compilers — so
+`pip install python-scalpel` fails on 3.12/3.13/3.14. `typed_ast` is imported by
+exactly one scalpel module, `typeinfer/analysers.py`, which codeanalyzer does not
+use. Vendoring the small slice the L4 may-alias oracle needs removes the
+`typed_ast` dependency and makes scalpel the default oracle on every supported
+Python.
+
+## What is vendored
+
+Exactly the 9-module closure that `scalpel.SSA.const` + `scalpel.cfg` load
+(verified via `sys.modules`; provably free of `typeinfer`/`typed_ast`):
+
+    __init__.py
+    SSA/__init__.py, SSA/const.py
+    cfg/__init__.py, cfg/builder.py, cfg/model.py
+    core/__init__.py, core/func_call_visitor.py, core/vars_visitor.py
+
+Copied verbatim except **one patch**: `cfg/model.py`'s top-level
+`import graphviz as gv` is guarded (`try/except ImportError: gv = None`) so the
+module imports without the `graphviz` package — the graphviz-using
+`build_visual()` methods are unused here.
+
+Runtime deps of this slice: `astor`, `networkx` (both core dependencies of
+codeanalyzer). `typed_ast` and `graphviz` are NOT required.
+
+To refresh: re-run the vendoring in `docs/superpowers/plans/2026-07-22-vendored-scalpel-default-oracle.md` Task 1.

codeanalyzer/dataflow/scalpel/SSA/__init__.py

@@ -0,0 +1,8 @@
+"""
+Static Single Assignment (SSA) is a technique of IR in the compiling thoery, it also shows great benefits to static anaysis tasks such as constant propagation, dead code elimination and etc.
+Constant propagation is also a matured technique in static anaysis. 
+It is the process of evaluating or recognizing the actual constant values or expressions at a particular program point. This is realized by utilizing control flow and data flow information. Determining the possible values for variables before runtime gives great benefits to software anaysis. 
+For instance, with constant value propagation, we can detect and remove dead code or perfrom type checking.
+In scalpel, we implement constant propagation along with the SSA for execution efficiency.
+"""
+__slots__ = ["const"]

codeanalyzer/dataflow/scalpel/SSA/const.py

@@ -0,0 +1,398 @@
+""" 
+In this module, the single static assignment forms are implemented to allow
+further analysis. The module contain a single class named SSA.
+"""
+import ast
+import astor
+from functools import reduce
+from collections import OrderedDict
+import networkx as nx
+from ..core.vars_visitor import get_vars
+
+def parse_val(node):
+    # does not return anything
+    if isinstance(node, ast.Constant):
+       return node.value
+    if isinstance(node, ast.Str):
+        if hasattr(node, "value"):
+            return node.value
+        else:
+            return node.s
+    return "other"
+
+
+class SSA:
+    """
+    Build SSA graph from a given AST node based on the CFG.
+    """
+    def __init__ (self):
+        """
+        Args:
+            src: the source code as input.
+        """
+        # the class SSA takes a module as the input 
+        self.numbering = {}  # numbering variables
+        self.var_values = {}  # numbering variables
+        self.global_live_idents = []
+        self.ssa_blocks = []
+        self.error_paths = {}
+        self.dom = {}
+
+        self.block_ident_gen = {}
+        self.block_ident_use = {}
+        self.reachable_table = {}
+        id2block = {}
+        self.unreachable_names = {}
+        self.undefined_names_from = {}
+        self.global_names = []
+
+    def get_attribute_stmts(self, stmts):
+        call_stmts = []
+        for stmt in stmts:
+            if isinstance(stmt,ast.Call) and isinstance(stmt.func, ast.Attribute):
+                call_stmts += [stmt]
+
+    def get_identifiers(self, ast_node):
+        """
+        Extract all identifiers from the given AST node.
+        Args:
+            ast_node: AST node.
+        """
+        if ast_node is None:
+            return []
+        res = get_vars(ast_node)
+        idents = [r['name'] for r in res if  r['name'] is not None and "." not in r['name']]
+        return idents
+
+    def compute_SSA(self, cfg):
+        """
+        Compute single static assignment form representations for a given CFG. 
+        During the computing, constant value and alias pairs are generated. The following steps are used to compute SSA representations:
+        step 1a: compute the dominance frontier
+        step 1b: use dominance frontier to place phi node
+        if node X contains assignment to a, put phi node for an in dominance frontier of X
+        adding phi function may require introducing additional phi function 
+        start from the entry node 
+        step2: rename variables so only one definition per name
+
+        Args:
+            cfg: a control flow graph.
+        """
+        # to count how many times a var is defined
+        ident_name_counter = {}
+        # constant assignment dict
+        ident_const_dict = {}
+        # step 1a: compute the dominance frontier
+        all_blocks = cfg.get_all_blocks()
+        id2blocks = {block.id:block for block in all_blocks}
+
+        block_loaded_idents = {block.id:[] for block in all_blocks}
+        block_stored_idents = {block.id:[] for block in all_blocks}
+
+        block_const_dict = {block.id:[] for block in all_blocks}
+
+        block_renamed_stored = {block.id:[] for block in all_blocks}
+        block_renamed_loaded = {block.id:[] for block in all_blocks}
+        
+        DF = self.compute_DF(all_blocks)
+
+        for block in all_blocks:
+            df_nodes = DF[block.id]
+            tmp_const_dict = {}
+            
+
+            for idx, stmt in enumerate(block.statements):
+                stmt_const_dict = {}
+                stored_idents, loaded_idents, func_names = self.get_stmt_idents_ctx(stmt, const_dict=stmt_const_dict) 
+                tmp_const_dict[idx] = stmt_const_dict
+                block_loaded_idents[block.id] += [loaded_idents]
+                block_stored_idents[block.id] += [stored_idents]
+                block_renamed_loaded[block.id] += [{ident:set() for ident in loaded_idents}]
+            
+            block_const_dict[block.id]  = tmp_const_dict
+        
+        for block in all_blocks:
+            stored_idents = block_stored_idents[block.id]
+            loaded_idents = block_loaded_idents[block.id]
+            n_stmts = len(stored_idents)
+            assert (n_stmts == len(loaded_idents))
+            affected_idents = []
+            tmp_const_dict = block_const_dict[block.id]
+            for i in range(n_stmts):
+                stmt_stored_idents = stored_idents[i]
+                stmt_loaded_idents = loaded_idents[i]
+                stmt_renamed_stored =  {}
+                
+                for ident in stmt_stored_idents:
+                    affected_idents.append(ident)
+                    if ident in ident_name_counter:
+                        ident_name_counter[ident] += 1
+                    else:
+                        ident_name_counter[ident] = 0
+                    # rename the var name as the number of assignments
+                    stmt_const_dict = tmp_const_dict[i]
+                    if ident in stmt_const_dict:
+                        ident_const_dict[(ident, ident_name_counter[ident])] = stmt_const_dict[ident]
+                        
+                    stmt_renamed_stored[ident] = ident_name_counter[ident]
+                block_renamed_stored[block.id] += [stmt_renamed_stored]
+                
+
+                #same block, number used identifiers
+                for ident in stmt_loaded_idents:
+                    # a list of dictions for each of idents used in this statement
+                    phi_loaded_idents = block_renamed_loaded[block.id][i]
+                    if ident in ident_name_counter:
+                        phi_loaded_idents[ident].add(ident_name_counter[ident])
+                   
+            df_block_ids = DF[block.id]
+            for df_block_id in df_block_ids:
+                df_block = id2blocks[df_block_id] 
+                block_ident_gen_produced = []
+                df_block_stored_idents = block_stored_idents[df_block_id]
+                for af_ident in affected_idents:
+                    # this for-loop process every statement in the block
+                    for idx, phi_loaded_idents in enumerate(block_renamed_loaded[df_block_id]):
+                        block_ident_gen_produced.extend(df_block_stored_idents[idx])
+                        if af_ident in block_ident_gen_produced:
+                            continue 
+                        # place phi function here this var used
+                        # if af_ident has been assigned in this block beforclee this statement, then discard it
+                        # so theck af_ident has been generated in this block 
+                        if af_ident in phi_loaded_idents:  
+                            phi_loaded_idents[af_ident].add(ident_name_counter[af_ident])
+    
+        return block_renamed_loaded, ident_const_dict
+
+    def get_stmt_idents_ctx(self, stmt, del_set=[], const_dict = {}):
+        """
+        Extract the contextual information of each of identifiers. 
+        For assignment statements, the assigned values for each of variables will be stored.
+        In addition, the del_set will store all deleted variables. 
+        Args:
+            stmt: statement from AST trees.
+            del_set: deleted identifiers
+            const_dict: a mapping relationship between variables and their assigned values in this statement
+        """
+        # if this is a definition of class/function, ignore
+        stored_idents = []
+        loaded_idents = []
+        func_names = []
+        # assignment with only one target
+        
+        if isinstance(stmt, ast.Assign):
+            targets = stmt.targets
+            value = stmt.value
+            if len(targets) == 1:
+                if hasattr(targets[0], "id"):
+                    left_name = stmt.targets[0].id
+                    const_dict[left_name] = stmt.value
+                elif isinstance(targets[0], ast.Attribute):
+                    left_name = astor.to_source(stmt.targets[0]).strip()
+                    const_dict[left_name] = value
+                # multiple targets are represented as tuple 
+                elif isinstance(targets[0], ast.Tuple):
+                    # value is also represented as tuple
+                    if isinstance(value, ast.Tuple):
+                        for elt, val in zip(targets[0].elts, value.elts):
+                            if hasattr(elt, "id"):
+                                left_name = elt.id
+                                const_dict[left_name] = val
+                            elif isinstance(targets[0], ast.Attribute):
+                                #TODO: resolve attributes
+                                pass
+                    # value is represented as call
+                    if isinstance(value, ast.Call):
+                        for elt in targets[0].elts:
+                            if hasattr(elt, "id"):
+                                left_name = elt.id
+                                const_dict[left_name] = value
+                            elif isinstance(targets[0], ast.Attribute):
+                                #TODO: resolve attributes
+                                pass
+            else:
+                # Note  in some python versions, there are more than one target for an assignment 
+                # while in some other python versions, multiple targets are deemed as ast.Tuple type in assignment statement
+                for target in stmt.targets:
+                    # this is an assignment to tuple such as a,b = fun()
+                    # then no valid constant value can be recorded for this statement
+                    if hasattr(target, "id"):
+                        left_name = target.id
+                        const_dict[left_name] = None  # TODO: design a type for these kind of values 
+                    elif isinstance(stmt.targets[0], ast.Attribute):
+                        #TODO: resolve attributes
+                        pass
+
+
+
+        # one target assignment with type annotations
+        if isinstance(stmt, ast.AnnAssign):
+            if hasattr(stmt.target, "id"):
+                left_name = stmt.target.id
+                const_dict[left_name] = stmt.value
+            elif isinstance(stmt.target, ast.Attribute):
+                #TODO: resolve attributes
+                pass
+        if isinstance(stmt, ast.AugAssign):
+            # note here , we need to rewrite this value to its extended form
+            # if the statement is "a += 1", then the assigned value should be a+1
+            if hasattr(stmt.target, "id"):
+                left_name = stmt.target.id
+                extended_right = ast.BinOp(ast.Name(left_name, ast.Load()), stmt.op, stmt.value)
+                const_dict[left_name] = extended_right
+            elif isinstance(stmt.target, ast.Attribute):
+                #TODO: resolve attributes
+                pass
+        if isinstance(stmt, ast.For):
+            # there is a variation of assignment in for loop
+            # in the case of :  for i in [1,2,3]
+            # the element of stmt.iter is the value of this assignment
+            if hasattr(stmt.target, "id"):   
+                left_name = stmt.target.id
+                iter_value = stmt.iter
+                # make a iter call
+                #iter_node = ast.Call(ast.Name("iter", ast.Load()), [stmt.iter], [])
+                # make a next call
+                #next_call_node = ast.Call(ast.Name("next", ast.Load()), [iter_node], [])
+                const_dict[left_name] = iter_value
+
+            elif isinstance(stmt.target, ast.Tuple):
+                # to handle for-loop uch as:
+                # for x, y in fun():
+                for elt in stmt.target.elts:
+                    if hasattr(elt, "id"):
+                        const_dict[elt.id] = stmt.iter
+            elif isinstance(stmt.target, ast.Attribute):
+                #TODO: resolve attributes
+                pass
+      
+            
+
+        if isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            stored_idents.append(stmt.name)
+            const_dict[stmt.name] = stmt
+            func_names.append(stmt.name)
+            new_stmt = stmt
+            new_stmt.body = []
+            ident_info = get_vars(new_stmt)
+            for r in ident_info:
+                if r['name'] is None:
+                    continue
+                if r['usage'] == "load":
+                    loaded_idents.append(r['name']) 
+            return stored_idents, loaded_idents, func_names
+ 
+        if isinstance(stmt, ast.ClassDef):
+            stored_idents.append(stmt.name)
+            const_dict[stmt.name] = None
+            func_names.append(stmt.name)
+            return stored_idents, loaded_idents, func_names
+
+        # if this is control flow statements, we should not visit its body to avoid duplicates
+        # as they are already in the next blocks
+        if isinstance(stmt, (ast.Import, ast.ImportFrom)):
+            for alias in stmt.names:
+                if alias.asname is None:
+                    stored_idents += [alias.name.split('.')[0]]
+                else:
+                    stored_idents += [alias.asname.split('.')[0]]
+            return stored_idents, loaded_idents, []
+
+        if isinstance(stmt, (ast.Try)):
+            for handler in stmt.handlers:
+                if handler.name is not None:
+                    stored_idents.append(handler.name)
+                    
+                if isinstance(handler.type, ast.Name):
+                    loaded_idents.append(handler.type.id)
+                elif isinstance(handler.type, ast.Attribute) and isinstance(handler.type.value, ast.Name):
+                    loaded_idents.append(handler.type.value.id)
+            return stored_idents, loaded_idents, []
+        if isinstance(stmt, ast.Global):
+            for name in stmt.names:
+                self.global_names.append(name)
+            return stored_idents, loaded_idents, []
+
+        visit_node = stmt
+
+        if isinstance(visit_node,(ast.If, ast.IfExp)):
+            # visit_node.body = []
+            # visit_node.orlse=[]
+            visit_node = stmt.test
+
+        elif isinstance(visit_node, (ast.With)):
+            visit_node.body = []
+            visit_node.orlse=[]
+
+        elif isinstance(visit_node, (ast.While)):
+            visit_node.body = []
+
+        elif isinstance(visit_node, (ast.For)):
+            visit_node.body = []
+
+        elif isinstance(visit_node, ast.Return):
+            # imaginary variable
+            stored_idents.append("<ret>")
+            const_dict["<ret>"] = visit_node.value
+        elif isinstance(visit_node, ast.Yield):
+            # imaginary variable
+            stored_idents.append("<ret>")
+            const_dict["<ret>"] = visit_node.value
+
+        ident_info = get_vars(visit_node)
+        for r in ident_info:
+            if r['name'] is None or "_hidden_" in r['name']:
+                continue
+            if r['usage'] == 'store':
+                stored_idents.append(r['name'])
+            else:
+                loaded_idents.append(r['name'])
+            if r['usage'] == 'del':
+                del_set.append(r['name'])
+        return stored_idents, loaded_idents, []
+
+    def to_json(self):
+        pass
+
+    def print_block(self, block):
+        return block.get_source()
+
+    # compute the dominators
+    def compute_idom(self, ssa_blocks):
+        """
+        Compute immediate dominators for each of blocks
+        Args:
+            ssa_blocks: blocks from a control flow graph.
+        """
+        # construct the Graph
+        entry_block = ssa_blocks[0]
+        G = nx.DiGraph()
+        for block in ssa_blocks: 
+            G.add_node(block.id)
+            exits = block.exits
+            preds =  block.predecessors
+            for link in preds+exits:
+                G.add_edge(link.source.id, link.target.id)
+        # DF = nx.dominance_frontiers(G, entry_block.id)
+        idom = nx.immediate_dominators(G, entry_block.id)
+        return idom
+
+    # compute dominance frontiers
+    def compute_DF(self, ssa_blocks):
+        """
+        Compute dominating frontiers for each of blocks
+        Args:
+            ssa_blocks: blocks from a control flow graph.
+        """
+        # construct the Graph
+        entry_block = ssa_blocks[0]
+        G = nx.DiGraph()
+        for block in ssa_blocks: 
+            G.add_node(block.id)
+            exits = block.exits
+            preds = block.predecessors
+            for link in preds+exits:
+                G.add_edge(link.source.id, link.target.id)
+        DF = nx.dominance_frontiers(G, entry_block.id)
+        #idom = nx.immediate_dominators(G, entry_block.id)
+        return DF

codeanalyzer/dataflow/scalpel/__init__.py

@@ -0,0 +1,11 @@
+"""
+Static Anaysis for Python Programs
+==================================
+Scalpel is a Python library integrating classical program anaysis algorithms
+with tailored features for Python language. It aims to provide simple and
+efficient solutions to software engineering researchers that are accessible to
+everybody and reusable in various contexts.
+"""
+
+__all__ = ["cfg", "call_graph", "SSA", "core", "typeinfer", "import_graph", "rewriter"]
+__version__ = '1.0dev'

codeanalyzer/dataflow/scalpel/cfg/__init__.py

@@ -0,0 +1,10 @@
+"""
+The control-flow graph(CFG) is an essential component in static flow analysis with applications such as program
+optimization and taint analysis.
+scalpel.cfg module is used to construct the control flow graph for given python programs. The basic unit in the CFG,
+Block, contains a list of sequential statements that can be executed in a program without any control jumps. The Blocks
+are linked by Link objects, which represent control flow jumps between two blocks and contain the jump conditions in
+the form of an expression. Please see the example diagram a control flow graph ![Fibonacci CFG](https://raw.githubusercontent.com/SMAT-Lab/Scalpel/main/docs/_static/resources/cfg_example.png)
+"""
+from .builder import CFGBuilder
+from .model import Block, Link, CFG