PCART  v1.4
Automated Repair of Python API Parameter Compatibility Issues
changeAnalyze.py
Go to the documentation of this file.
1 
10 
11 
12 
13 import os
14 import re
15 import copy
16 import subprocess
17 from API.LibApi import Parameter
18 from Map.map import fuzzymatch
19 from Tool.tool import getParameter,removeParameter,getFileName,resolvePythonExecutable
20 
21 
22 
23 
28 class Update():
29 
30 
32  def __init__(self):
33 
34 
36  self.pospos=-1
37 
38 
40  self.typetype=''
41 
42 
44  self.renamerename=''
45 
46 
48  self.reprep=''
49 
50 
56  self.valuevalue=''
57 
58 
60  self.deledele=''
61 
62 
64  self.addPosaddPos=''
65 
66 
68  self.addKeyaddKey=''
69 
70 
72  self.pos2keypos2key=''
73 
74 
76  self.key2poskey2pos=''
77 
78 
79 
80 
82  def __repr__(self):
83  s=''
84  if self.pospos:
85  s+=f"posChange:{self.pos}, "
86  if self.typetype:
87  s+=f"typeChange:{self.type}, "
88  if self.deledele:
89  s+=f"delete:{self.dele}, "
90  if self.add:
91  s+=f"add:{self.add}, "
92  s=s.rstrip(', ')
93  return s
94 
95 
96 
97 
102 def updateErrorLst(errorLog,errorLst):
103  with open(errorLog, 'a', encoding='utf-8') as fw:
104  for it in errorLst:
105  fw.write(it)
106  fw.write('\n')
107 
108 
109 
110 
115 def querySharedDict(callAPI,sharedDict):
116  ansDict={}
117  k=callAPI
118  if k in sharedDict:
119  ansDict['current']=sharedDict[k]['current']
120  ansDict['target']=sharedDict[k]['target']
121  return ansDict
122  return ansDict
123 
124 
125 
126 
133 def updateSharedDict(callAPI,currentDict,targetDict,sharedDict):
134  key=callAPI
135  if key not in sharedDict: #没有就添加
136  sharedDict[key]={}
137  innerDict=sharedDict[key]
138  innerDict['current']=currentDict
139  innerDict['target']=targetDict
140  sharedDict[key]=innerDict #将修改操作更新到共享字典中
141  else: #存在则再看是否需要修改
142  innerDict=sharedDict[key]
143  if sharedDict[key]['current']['matchMethod']=='static' and currentDict['matchMethod']=='dynamic':
144  innerDict['current']=currentDict
145  if sharedDict[key]['target']['matchMethod']=='static' and targetDict['matchMethod']=='dynamic':
146  innerDict['target']=targetDict
147  sharedDict[key]=innerDict #将修改操作更新到共享字典中
148 
149 
150 
151 
163 def isDifferType(oldType,newType):
164  #先从字面值上判断看是否一样
165  if oldType==newType:
166  return False
167  #若至少存在一个类型注释为空,则认为二者的类型是相同的
168  if oldType=="" or newType=="":
169  return False
170  #若都存在类型注释且注释不同时,才认为二者的类型不同
171  else:
172  oldLst=[]
173  newLst=[]
174  oldTypeSet=set() #将类型构造成集合进行比较
175  newTypeSet=set()
176  if oldType[0]=="'" and oldType[-1]=="'":
177  oldType=oldType[1:-1]
178 
179  if newType[0]=="'" and newType[-1]=="'":
180  newType=newType[1:-1]
181 
182  if 'Union' in oldType:
183  pattern=r'.*?Union\[(.*)\].*?'
184  result=re.findall(pattern,oldType)
185  oldLst=getParameter(result[0])
186  elif 'Optional' in oldType:
187  pattern=r'.*?Optional\[(.*)\].*?'
188  result=re.findall(pattern,oldType)
189  oldLst=getParameter(result[0])
190  elif '|' in oldType:
191  oldLst=oldType.split('|')
192  else: #当oldType就是一个具体的类型而不是集合时,比如int
193  oldLst=[oldType]
194 
195  for it in oldLst:
196  oldTypeSet.add(it.replace(' ',''))
197 
198 
199 
200  if 'Union' in newType:
201  pattern=r'.*?Union\[(.*)\].*?'
202  result=re.findall(pattern,newType)
203  newLst=getParameter(result[0])
204  elif 'Optional' in newType:
205  pattern=r'.*?Optional\[(.*)\].*?'
206  result=re.findall(pattern,newType)
207  newLst=getParameter(result[0])
208  elif '|' in newType:
209  newLst=newType.split('|')
210  else:
211  newLst=[newType]
212 
213  for it in newLst:
214  newTypeSet.add(it.replace(' ',''))
215 
216  #这里oldTypeSet>0是因为避免空集是任意集合的子集的情况
217  if len(oldTypeSet)>0 and oldTypeSet.issubset(newTypeSet):
218  return False
219  else:
220  return newType
221 
222 
223 
224 
229 def para2Obj(paraStr):
230  paraStr=paraStr.replace(' ','') #去空格
231  paraObjLst=[] #保存参数对象
232  if '->' in paraStr: #若有有返回值的话去掉返回值
233  paraStr=paraStr.split('->')[0]
234  if '(' in paraStr[0]:
235  paraStr=paraStr[1:-1]
236 
237  if paraStr:
238  lst=getParameter(paraStr)
239  else:
240  lst=[]
241  lst=[para for para in lst if para != '/'] # 2026/4/23 当前修复模型只区分args/kwargs,忽略仅位置参数分隔符
242  if len(lst)>0:
243  if 'self' in lst[0]: #self可能也存在类型注释
244  lst.remove(lst[0])
245  elif 'cls' in lst[0]:
246  lst.remove(lst[0])
247  for para in lst:
248  parameter=Parameter()
249  parameter.position=lst.index(para) #当列表中有相同元素时,lst.index会出现问题,但库定义中不会出现相同的参数
250  parameter.fullItem=para
251  flagMaohao=0
252  if ':' in para:
253  pos=para.find(':')
254  flagMaohao=1
255 
256  if flagMaohao and "'" not in para[0:pos] and '"' not in para[0:pos] and '<' not in para[0:pos]: #参数值为字符串时,字符串中也可能出现冒号
257  l=para.split(':')
258  parameter.name=l[0]
259  if '=' in l[1]:
260  ll=l[1].split('=')
261  parameter.type=ll[0]
262  parameter.value=ll[1]
263  else:
264  parameter.type=l[1]
265  elif '=' in para:
266  l=para.split('=')
267  parameter.name=l[0]
268  parameter.value=l[1]
269  else:
270  parameter.name=para
271  paraObjLst.append(parameter)
272 
273  pos=len(paraObjLst)
274  posStar=-1 #记录*的位置
275  pos2Star=-1 #记录**的位置, 防止出现(x, y, **kwargs)的形式
276  for para in paraObjLst:
277  if '**' in para.name:
278  pos2Star=para.position
279  elif '*' in para.name:
280  posStar=para.position
281  break
282  if posStar!=-1: #优先根据*号拆分
283  pos=posStar
284  elif pos2Star!=-1:
285  pos=pos2Star
286 
287  posParameters=paraObjLst[0:pos]
288  keyParameters=[]
289  for para in paraObjLst[pos+1:]:
290  if '**' not in para.name:
291  keyParameters.append(para)
292 
293  return posParameters,keyParameters
294 
295 
296 
297 
304 def findDiffer(oldPara,newPara,*,includeValue=False):
305  oldPos,oldKey=para2Obj(oldPara)
306  newPos,newKey=para2Obj(newPara)
307  oldPosParaNum=len(oldPos)
308  dic={} #保存每个参数应该做哪些修改操作
309  #第一轮筛选,先根据名字来找对应关系
310  #处理位置参数
311  for oldPara in copy.deepcopy(oldPos):
312  sameFlag=0
313  for newPara in newPos:
314  if oldPara.name==newPara.name:
315  up=Update()
316  if oldPara.position!=newPara.position:
317  up.pos=newPara.position
318  ty=isDifferType(oldPara.type,newPara.type)
319  if ty:
320  up.type=ty
321  if oldPara.value!=newPara.value:
322  up.value={'old':oldPara.value,'new':newPara.value}
323  sameFlag=1
324  oldPos.remove(oldPara)
325  newPos.remove(newPara)
326  break
327  if sameFlag==1:
328  dic[(oldPara.name,oldPara.position)]=up
329 
330  #处理关键字参数,旧版中没有找到相同名字的参数可能是重命名或删除了
331  for oldPara in copy.deepcopy(oldKey):
332  sameFlag=0
333  for newPara in newKey:
334  if oldPara.name==newPara.name:
335  up=Update()
336  ty=isDifferType(oldPara.type,newPara.type)
337  if ty:
338  up.type=ty
339  if oldPara.value!=newPara.value:
340  up.value={'old':oldPara.value,'new':newPara.value}
341  sameFlag=1
342  oldKey.remove(oldPara)
343  newKey.remove(newPara)
344  break
345  if sameFlag==1:
346  dic[(oldPara.name,oldPara.position)]=up
347 
348 
349 
350  #第二轮筛选,根据名字找对应关系,判断是否存在位置参数变到了关键字参数
351  for oldPara in copy.deepcopy(oldPos):
352  sameFlag=0
353  for newPara in newKey:
354  if oldPara.name==newPara.name:
355  up=Update()
356  up.pos2key=oldPara.name #位置参数变成关键字参数
357  ty=isDifferType(oldPara.type,newPara.type)
358  if ty:
359  up.type=ty
360  if oldPara.value!=newPara.value:
361  up.value={'old':oldPara.value,'new':newPara.value}
362  sameFlag=1
363  oldPos.remove(oldPara)
364  newKey.remove(newPara)
365  break
366  if sameFlag==1:
367  dic[(oldPara.name,oldPara.position)]=up
368 
369 
370  #再判断是否有关键字参数(起始版本)变到了位置参数(目标版本)
371  for oldPara in copy.deepcopy(oldKey):
372  sameFlag=0
373  for newPara in copy.deepcopy(newPos):
374  if oldPara.name==newPara.name:
375  print(f"key2pos-->{oldPara.name}")
376  up=Update()
377  up.key2pos=oldPara.name
378  ty=isDifferType(oldPara.type, newPara.type)
379  if ty:
380  up.type=ty
381  if oldPara.value!=newPara.value:
382  up.value={'old':oldPara.value,'new':newPara.value}
383  sameFlag=1
384  oldKey.remove(oldPara)
385  newPos.remove(newPara)
386  break
387  if sameFlag==1:
388  dic[(oldPara.name,oldPara.position)]=up
389 
390 
391 
392 
393  #第三轮筛选,根据对应位置和类型来筛选剩余的位置参数,判断其是否发生了重命名
394  for oldPara in copy.deepcopy(oldPos):
395  sameFlag=0
396  for newPara in newPos:
397  if oldPara.position==newPara.position and not isDifferType(oldPara.type,newPara.type): #这里需要加一个类型相同约束吗
398  up=Update()
399  if oldPara.name!=newPara.name: #参数发生了重命名
400  up.rename=newPara.name
401  ty=isDifferType(oldPara.type,newPara.type)
402  if ty:
403  up.type=ty
404  if oldPara.value!=newPara.value:
405  up.value={'old':oldPara.value,'new':newPara.value}
406  sameFlag=1
407  oldPos.remove(oldPara)
408  newPos.remove(newPara)
409  break
410  if sameFlag==1:
411  dic[(oldPara.name,oldPara.position)]=up
412  else:#oldPos中剩下的就是删除的
413  oldPos.remove(oldPara)
414  up=Update()
415  up.dele=1
416  dic[(oldPara.name,oldPara.position)]=up
417 
418  #第四轮筛选,根据类型来判断,剩余的关键字参数是否发生了重命名
419  for oldPara in copy.deepcopy(oldKey):
420  sameFlag=0
421  for newPara in newKey:
422  if oldPara.type==newPara.type:
423  sameFlag=1
424  up=Update()
425  up.rename=newPara.name
426  if oldPara.value!=newPara.value:
427  up.value={'old':oldPara.value,'new':newPara.value}
428  oldKey.remove(oldPara)
429  newKey.remove(newPara)
430  break
431  if sameFlag==1:
432  dic[(oldPara.name,oldPara.position)]=up
433  else:
434  oldKey.remove(oldPara)
435  up=Update()
436  up.dele=1
437  dic[(oldPara.name,oldPara.position)]=up
438 
439 
440  #newPos中剩下的就是替换或新增的
441  for para in newPos:
442  s=f'{para.name}'
443  if para.value:
444  s+=f"={para.value}"
445  if para.position>=0 and para.position<oldPosParaNum: #如果剩余参数的下标在旧版本参数下标的范围内,则认为是替换操作,反之则认为是新增的
446  for key in dic:
447  if key[1]==para.position:
448  dic[key].rep=s
449  break
450  else:
451  up=Update()
452  up.addPos=s
453  dic[(para.name,para.position)]=up
454 
455  #newKey中剩下的就是新增的,新增的关键字参数往往都带有默认值,一般不会引起兼容性问题
456  for para in newKey:
457  s=para.name
458  if para.value:
459  s+=f"={para.value}"
460  up=Update()
461  up.addKey=s
462  dic[(para.name,para.position)]=up
463 
464 
465  #构建修改操作的字典
466  updateDict={}
467  for key,value in dic.items():
468  if key not in updateDict:
469  updateDict[key]={}
470  if value.dele:
471  updateDict[key]['delete']=value.dele
472  if value.type:
473  updateDict[key]['typeChange']=value.type
474  if value.rename:
475  updateDict[key]['rename']=value.rename
476  if value.pos!=-1:
477  updateDict[key]['posChange']=value.pos
478  if value.rep:
479  updateDict[key]['replace']=value.rep
480  if value.pos2key:
481  updateDict[key]['pos2key']=value.pos2key
482  if value.addPos:
483  updateDict[key]['addPos']=value.addPos
484  if value.addKey:
485  updateDict[key]['addKey']=value.addKey
486  if value.key2pos:
487  updateDict[key]['key2pos']=value.key2pos
488  # 仅在显式开启时记录默认值变更。
489  if includeValue and value.value:
490  updateDict[key]['value']=value.value
491 
492  #对字典按照参数的位置进行排序
493  ansDict=dict(sorted(updateDict.items(), key=lambda it: it[0][1])) #it[0]代表字典的键,it[0][1]代表键中的第二个元素,即位置
494  return ansDict
495 
496 
497 
498 
509 def analyzeCompatibility(oldPara,newPara):
510  #将其转化为参数对象
511  oldPos,oldKey=para2Obj(oldPara)
512  newPos,newKey=para2Obj(newPara)
513  #分析位置参数
514  for oldPara in oldPos:
515  flag=0
516  for newPara in newPos:
517  if oldPara.name==newPara.name and oldPara.position==newPara.position and not isDifferType(oldPara.type,newPara.type):
518  flag=1
519  break
520  if flag==0: #若旧版本的位置参数没有在新版本中找到对应的
521  return False
522 
523  #再分析新增的位置参数
524  for newPara in newPos:
525  if newPara.position>=len(oldPos):
526  if newPara.value=='': #若新增的位置参数不带默认值
527  return False
528 
529  #分析关键字参数
530  for oldPara in oldKey:
531  flag=0
532  for newPara in newKey:
533  if oldPara.name==newPara.name and not isDifferType(oldPara.type,newPara.type):
534  flag=1
535  break
536 
537  #再判断关键字参数是否变成了位置参数(这种改变是兼容的)
538  if flag==0:
539  for newPara in newPos:
540  if oldPara.name==newPara.name and not isDifferType(oldPara.type,newPara.type):
541  flag=1
542  print(f"key2pos-->{oldPara.name}")
543  break
544 
545  if flag==0:
546  return False
547 
548  #再分析新增的关键字参数
549  #比如(*,x,y) --> (*,x,y,z),其中z就是新增的
550  for newPara in newKey:
551  flag=0
552  for oldPara in oldKey:
553  if newPara.name==oldPara.name: #若找到同名的,则不是新增的
554  flag=1
555  break
556  if flag==0:
557  if newPara.value=='': #若新增的关键字参数不带默认值
558  return False
559 
560  return True
561 
562 
563 
564 
572 def isCompatible(current,target):
573  if len(current['match'])==0 or len(target['match'])==0:
574  return None
575  # if "*args" in target['match'] or "**kwargs" in target['match'] or "**" in target['match']: #默认此时是兼容的
576  # return []
577  #先将数据结构统一化,便于之后的统一操作
578  if isinstance(current['match'],str): #只要是str,一定是动态匹配
579  currentDict={current['internalPath']:[current['match']]}
580  else:
581  currentDict=current['match']
582 
583  if isinstance(target['match'],str):
584  targetDict={target['internalPath']:[target['match']]}
585  else:
586  targetDict=target['match']
587 
588  tempLst1=[] #保存找到了对应关系的配对的修复字典
589  tempLst2=[] #保存未确定对应关系的配对的修复字典
590  flag=0
591  for currentSameAPI,currentOvLst in currentDict.items():
592  for targetSameAPI,targetOvLst in targetDict.items():
593  if currentSameAPI==targetSameAPI or (currentSameAPI+'.' in targetSameAPI) or (targetSameAPI+'.' in currentSameAPI) or len(currentDict)==1 and len(targetDict)==1:
594  flag=1
595  #第一轮遍历,筛选掉两个同名API确定对应关系的重载,这里对应关系的规则是字符串完全一致
596  #只要能找到对应关系,就说明是兼容的
597  #新版中完全对应的可以删除,但兼容的不能删除,防止它还可以兼容旧版本的其它重载
598  for currentOvPara in copy.deepcopy(currentOvLst):
599  for targetOvPara in copy.deepcopy(targetOvLst):
600  if currentOvPara.split('->')[0]==targetOvPara.split('->')[0]:
601  currentOvLst.remove(currentOvPara)
602  targetOvLst.remove(targetOvPara)
603 
604  #第二轮遍历
605  #只要旧版本的API在新版本中找到一个和它兼容的,那就认为旧版本的API在新版本中是兼容的,无需再进行其它的判断。
606  #只有旧版本的API在新版本中都不兼容时,才认为它不兼容,不兼容就要依次尝试修复。
607  for currentOvPara in currentOvLst:
608  compatibleFlag=0
609  for targetOvPara in targetOvLst:
610  if analyzeCompatibility(currentOvPara,targetOvPara):
611  compatibleFlag=1
612  break
613 
614  if compatibleFlag==0: #如果都不兼容,则需要尝试修复
615  for targetOvPara in targetOvLst: #这里
616  repairDict=findDiffer(currentOvPara,targetOvPara)
617  tempLst1.append((repairDict,targetOvPara))
618 
619  else:
620  for currentOvPara in currentOvLst:
621  compatibleFlag=0
622  for targetOvPara in targetOvLst:
623  if analyzeCompatibility(currentOvPara,targetOvPara):
624  compatibleFlag=1
625  break
626 
627  if compatibleFlag==0: #如果都不兼容,则需要尝试修复
628  for targetOvPara in targetOvLst: #这里
629  repairDict=findDiffer(currentOvPara,targetOvPara)
630  tempLst2.append((repairDict,targetOvPara))
631 
632  if flag==1:
633  return tempLst1
634  else:
635  return tempLst2
636 
637 
638 
639 
649 def analyzeMatchCompatibility(current,target,*,formatAPI,libName,currentVersion,targetVersion):
650  currentMethod=current.get('matchMethod')
651  targetMethod=target.get('matchMethod')
652  if {currentMethod,targetMethod}=={'dynamic','static'}:
653  if currentMethod=='dynamic':
654  dynamicMatchInfo=current
655  staticMatchInfo=target
656  dynamicVersion=currentVersion
657  dynamicIsCurrent=True
658  else:
659  dynamicMatchInfo=target
660  staticMatchInfo=current
661  dynamicVersion=targetVersion
662  dynamicIsCurrent=False
663 
664  staticCandidates=staticMatchInfo.get('match',{})
665  #静态侧完整路径精确命中时直接比较参数,不要求公开路径等于内部路径
666  if isinstance(staticCandidates,dict) and len(staticCandidates)==1 and formatAPI in staticCandidates:
667  return isCompatible(current,target)
668 
669  dynamicStaticMatch=fuzzymatch(formatAPI,libName,dynamicVersion,0)
670  qualifiedName=dynamicMatchInfo.get('qualifiedName')
671  if isinstance(qualifiedName,str) and isinstance(dynamicStaticMatch,dict) and isinstance(staticCandidates,dict) \
672  and qualifiedName in dynamicStaticMatch and qualifiedName in staticCandidates:
673  dynamicStaticCompare={'match':{qualifiedName:list(dynamicStaticMatch[qualifiedName])}}
674  staticCompare={'match':{qualifiedName:list(staticCandidates[qualifiedName])}}
675  if dynamicIsCurrent:
676  return isCompatible(dynamicStaticCompare,staticCompare)
677  return isCompatible(staticCompare,dynamicStaticCompare)
678  return None
679 
680  return isCompatible(current,target)
681 
682 
683 
684 
697 def addValueForAPI(callAPI,projName,runPath,runCommand,currentEnv,targetEnv,errLst,callKey,*,runtimePaths):
698  copyRoot=runtimePaths['copy_root']
699  dynamicRoot=runtimePaths['dynamic_root']
700  pklKey = callKey
701  pklName=getFileName(pklKey,'.pkl')
702  flag=0
703  # 参数补值沿用动态匹配的候选顺序,并优先使用目标环境重新生成的pkl
704  pklCandidates=[
705  ('new_'+pklName[:-4]+'__object.pkl',1),
706  ('new_'+pklName[:-4]+'__expr.pkl',1),
707  ('new_'+pklName,1),
708  (pklName[:-4]+'__object.pkl',0),
709  (pklName[:-4]+'__expr.pkl',0),
710  (pklName,0),
711  ]
712  pklPath=''
713  for candidateName,candidateFlag in pklCandidates:
714  candidatePath=os.path.join(copyRoot,'pkl',candidateName)
715  if os.path.exists(candidatePath):
716  flag=candidateFlag
717  pklPath=candidatePath
718  break
719  if not pklPath:
720  return ''
721 
722  #当runPath不在runCommand中时,需要切换到运行文件所在的目录执行命令
723  #而文件操作的相对路径就是相对于命令执行的路径
724  # pythonPath=f"{virtualEnv}/bin/python"
725  if flag==0:
726  pythonPath = resolvePythonExecutable(currentEnv)
727  else:
728  pythonPath = resolvePythonExecutable(targetEnv)
729 
730  if runPath and runPath not in runCommand:
731  cwd = os.path.join(dynamicRoot, projName, runPath)
732  script = 'addValueForAPI.py'
733  elif runPath:
734  cwd = os.path.join(dynamicRoot, projName)
735  script = os.path.join(runPath, 'addValueForAPI.py')
736  else:
737  cwd = os.path.join(dynamicRoot, projName)
738  script = 'addValueForAPI.py'
739  matchResult = subprocess.run([pythonPath, script, pklPath, callAPI, pklKey],cwd=cwd, capture_output=True, text=True, encoding='utf-8')
740  if matchResult.returncode!=0:
741  errLst.append(f"{callAPI}, addValueError: {matchResult.stderr}\n")
742  return ''
743 
744  output=matchResult.stdout
745  pattern="##(.*)##"
746  obj=re.compile(pattern,re.DOTALL)
747  lst=obj.findall(output)
748  if len(lst)==1:
749  return lst[0]
750 
751  return ''
Update class for parameter change analysis 参数变更分析类
pos2key
Conversion of positional parameter to keyword parameter 位置参数变更为关键字参数
rename
New name of the parameter 参数重命名
dele
Flag (1) of parameter deletion 参数删除标记 (1)
addPos
New positional parameter 新增位置参数
key2pos
Conversion of keyword parameter to positional parameter 关键字参数变更为位置参数
addKey
New keyword parameter 新增关键字参数
type
New type of the parameter 参数新类型
def __repr__(self)
Return the string representation of the parameter update 返回参数变更的字符串表示形式
rep
Replacement of the parameter 参数替换
pos
New position of the parameter 参数新位置
def __init__(self)
The constructor 构造函数
value
New default value of the parameter 参数新默认值
def analyzeCompatibility(oldPara, newPara)
Analyze the compatibility of two APIs 判断两个重载API是否兼容
def analyzeMatchCompatibility(current, target, *formatAPI, libName, currentVersion, targetVersion)
Analyze compatibility after selecting comparable matching results 选择可比较的匹配结果,再分析版本间兼容性
def isCompatible(current, target)
Determine the compatibility of APIs from current and target versions 判断起始版本和目标版本API的兼容性
def updateErrorLst(errorLog, errorLst)
Save error messages 保存错误信息
def para2Obj(paraStr)
Convert parameter string to positional and keyword parameter objects 将参数字符串转换为位置和关键字参数对象
def isDifferType(oldType, newType)
Determine parameter type change: compatible type means no type change 判断两个参数的类型是否发生了变更: 只要兼容,就认为相同
def updateSharedDict(callAPI, currentDict, targetDict, sharedDict)
Update API mapping dictionary: add and revise 更新API映射字典: 添加和修改
def findDiffer(oldPara, newPara, *includeValue=False)
Determine difference of two parameters 输入两个api参数部分,判断参数部分有何不同
def querySharedDict(callAPI, sharedDict)
Query API mapping dictionary 查询API映射字典
def addValueForAPI(callAPI, projName, runPath, runCommand, currentEnv, targetEnv, errLst, callKey, *runtimePaths)
Add values stored by pkl file for API parameters 为API参数添加保存至pkl文件中的值
def getFileName(fileName, extension)
Normalize and sanitize file name 规范化并清理文件名
Definition: codeUtils.py:66
def getParameter(p_string, separator=',', space=1)
Split parameter string into list of separated parameters 将参数字符串拆分成单个的参数
Definition: codeUtils.py:244
def fuzzymatch(formatAPI, libName, version, builtinFlag)
Static mapping of API signatures API签名静态匹配
Definition: map.py:57
def resolvePythonExecutable(envPath)
Resolve Python executable from a virtual environment root 从虚拟环境根目录解析 Python 解释器路径
Definition: tool.py:491