extractCall.py

Go to the documentation of this file.

 
 
 
 
import ast
 
 
 
 
class Import(ast.NodeVisitor):
    
    def __init__(self):
        self._md_name_md_name={}
 
    
    def get_md_name(self):
        return self._md_name_md_name
 
    
    def visit_Import(self, node):
        item=[nn.__dict__ for nn in node.names] #item中每个元素都是一个字典
        for it in item:
            if it["asname"] is None:
                self._md_name_md_name[it["name"]]=it["name"]
            else:
                self._md_name_md_name[it["asname"]]=it["name"]
 
    
    def visit_ImportFrom(self, node):
        if node.module is not None:
            item=[nn.__dict__ for nn in node.names]
            for it in item:
                if it["asname"] is None:
                    self._md_name_md_name[it["name"]]=node.module+'.'+it["name"]
                else:
                    self._md_name_md_name[it["asname"]]=node.module+'.'+it["name"]
 
 
 
 
class GetFuncCall:
    
    def __init__(self):
        self._func_call_func_call=[] #list中每个元素都是一个tuple
 
    
    @property
    def func_call(self):
        return self._func_call_func_call
 
    
    def dfsVisit(self,node):
        #先递推再回归 
        for n in ast.iter_child_nodes(node):
            self.dfsVisitdfsVisit(n)
        
        if isinstance(node,ast.Call):
            callName=ast.unparse(node.func)
            callState=ast.unparse(node) #还原之后的语句可能和项目中的语句存在差异，比如空格等
            argLst=[]
            for arg in node.args:
                argLst.append(ast.unparse(arg))
            for keyword in node.keywords:
                argLst.append(ast.unparse(keyword))
            parameters=','.join(argLst)
            callInfo=(
                callName,
                parameters,
                callState,
                node.lineno,
                node.col_offset,
                getattr(node,'end_lineno',None),
                getattr(node,'end_col_offset',None),
            )
            if callInfo not in self._func_call_func_call:
                self._func_call_func_call.append(callInfo)
            else:
                pass
            return
 
 
 
 
class WithVisitor(ast.NodeVisitor):
    
    def __init__(self):
        self._withitemCall_withitemCall={}
 
    
    def get_withitem_call(self):
        return self._withitemCall_withitemCall
 
    
    def visit_With(self, node):
        self._visit_with_items_visit_with_items(node)
        for stmt in node.body:
            self.visit(stmt)
 
    
    def visit_AsyncWith(self, node):
        self._visit_with_items_visit_with_items(node)
        for stmt in node.body:
            self.visit(stmt)
 
    
    def _visit_with_items(self, node):
        for item in node.items:
            self._record_withitem_record_withitem(item, node)
 
    
    def visit_withitem(self, node):
        self._record_withitem_record_withitem(node)
 
    
    def _record_withitem(self, node, parent=None):
        if isinstance(node.context_expr, ast.Call):
            if node.optional_vars:
                callName =  ast.unparse(node.context_expr)
                aliasName = ast.unparse(node.optional_vars)
                # lineno/end_lineno用于后续按调用点选择当前作用域内的withitem
                item = {
                    'callName': callName,
                    'lineno': getattr(parent, 'lineno', None),
                    'end_lineno': getattr(parent, 'end_lineno', None),
                }
                self._withitemCall_withitemCall.setdefault(aliasName, []).append(item)