from a.b import foo_method
新的:
from b.d import bar_method
这两个方法(foo_method()和bar_method())是相同的。只是名称和包名发生了变化。
由于上面的例子只是方法导入方式的众多示例之一，我认为简单的正则表达式在这里无法帮助。
如何通过命令行工具重构导入模块?
许多源代码行需要更改，因此IDE无法帮助处理此问题。
def potential(line):
# This is just a minimal example; replace with more reliable expression
return "foo_method" in line or "a.b" in line
matches = ["from a.b import foo_method"] # Add more to the list if necessary
new = "from b.d import bar_method"
# new = "from b.d import bar_method as foo_method"
file = "file.py"
result = ""
with open(file) as f:
for line in f:
for match in matches:
if match in line:
result += line.replace(match, new)
break
else:
if potential(line):
print(line)
# Here is the part where you manually check lines that potentially needs editing
new_line = input("Replace with... (leave blank to ignore) ")
if new_line:
result += new_line + "\n"
continue
result += line
with open(file, "w") as f:
f.write(result)
最后，为了避免在重命名每个实例时出现问题，从对于普通用途而言，仅有前三种方式才是重要的:
import modulefrom module import this, that, totherfrom module import *
foo_method到bar_method，我建议使用as关键字将新命名的bar_method作为foo_method导入。幕后，集成开发环境（IDE）不过是带有许多窗口和附加二进制文件以执行各种任务的文本编辑器，例如编译、调试、代码标记、静态代码分析等。最终，其中一个库可以用于重构代码。其中一个这样的库是Jedi，但有一个专门用于处理重构的库，它是rope。
pip3 install rope
你可以尝试使用他们的API，但是既然你要求一个命令行工具而且没有提供，那么请将以下文件保存在任何可访问的地方（已知相对文件夹、用户bin等）并使其可执行chmod +x pyrename.py。
#!/usr/bin/env python3
from rope.base.project import Project
from rope.refactor.rename import Rename
from argparse import ArgumentParser
def renamodule(old, new):
prj.do(Rename(prj, prj.find_module(old)).get_changes(new))
def renamethod(mod, old, new, instance=None):
mod = prj.find_module(mod)
modtxt = mod.read()
pos, inst = -1, 0
while True:
pos = modtxt.find('def '+old+'(', pos+1)
if pos < 0:
if instance is None and prepos > 0:
pos = prepos+4 # instance=None and only one instance found
break
print('found', inst, 'instances of method', old+',', ('tell which to rename by using an extra integer argument in the range 0..' if (instance is None) else 'could not use instance=')+str(inst-1))
pos = -1
break
if (type(instance) is int) and inst == instance:
pos += 4
break # found
if instance is None:
if inst == 0:
prepos = pos
else:
prepos = -1
inst += 1
if pos > 0:
prj.do(Rename(prj, mod, pos).get_changes(new))
argparser = ArgumentParser()
#argparser.add_argument('moduleormethod', choices=['module', 'method'], help='choose between module or method')
subparsers = argparser.add_subparsers()
subparsermod = subparsers.add_parser('module', help='moduledottedpath newname')
subparsermod.add_argument('moduledottedpath', help='old module full dotted path')
subparsermod.add_argument('newname', help='new module name only')
subparsermet = subparsers.add_parser('method', help='moduledottedpath oldname newname')
subparsermet.add_argument('moduledottedpath', help='module full dotted path')
subparsermet.add_argument('oldname', help='old method name')
subparsermet.add_argument('newname', help='new method name')
subparsermet.add_argument('instance', nargs='?', help='instance count')
args = argparser.parse_args()
if 'moduledottedpath' in args:
prj = Project('.')
if 'oldname' not in args:
renamodule(args.moduledottedpath, args.newname)
else:
renamethod(args.moduledottedpath, args.oldname, args.newname)
else:
argparser.error('nothing to do, please choose module or method')
让我们创建一个测试环境，与问题中显示的情景完全相同（这里假设使用Linux用户）：
cd /some/folder/
ls pyrename.py # we are in the same folder of the script
# creating your test project equal to the question in prj child folder:
mkdir prj; cd prj; cat << EOF >> main.py
#!/usr/bin/env python3
from a.b import foo_method
foo_method()
EOF
mkdir a; touch a/__init__.py; cat << EOF >> a/b.py
def foo_method():
print('yesterday i was foo, tomorrow i will be bar')
EOF
chmod +x main.py
# testing:
./main.py
# yesterday i was foo, tomorrow i will be bar
cat main.py
cat a/b.py
# be sure that you are in the project root folder
# rename package (here called module)
../pyrename.py module a b
# package folder 'a' renamed to 'b' and also all references
# rename module
../pyrename.py module b.b d
# 'b.b' (previous 'a.b') renamed to 'd' and also all references also
# important - oldname is the full dotted path, new name is name only
# rename method
../pyrename.py method b.d foo_method bar_method
# 'foo_method' in package 'b.d' renamed to 'bar_method' and also all references
# important - if there are more than one occurence of 'def foo_method(' in the file,
# it is necessary to add an extra argument telling which (zero-indexed) instance to use
# you will be warned if multiple instances are found and you don't include this extra argument
# testing again:
./main.py
# yesterday i was foo, tomorrow i will be bar
cat main.py
cat b/d.py
这个例子完全做到了问题所要求的。
只实现了重命名模块和方法，因为这是问题的范围。如果您需要更多，可以增加脚本或从头开始创建一个新的脚本，学习他们的文档和这个脚本本身。为了简单起见，我们使用当前文件夹作为项目文件夹，但您可以在脚本中添加额外的参数使其更加灵活。
libcst项目没有关联）。libcst目前还不支持Python 3.10+。from a.b import foo_method语句foo_methodfrom b.d import bar_methodbar_methodleave_Node，其中Node是我们要检查和转换的节点类型（我们还可以指定visit_Node方法，但本例中不需要）。在方法中，我们使用匹配器来检查节点是否符合我们的转换标准。import libcst as cst
import libcst.matchers as m
src = """\
import foo
from a.b import foo_method
class C:
def do_something(self, x):
return foo_method(x)
"""
class ImportFixer(cst.CSTTransformer):
def leave_SimpleStatementLine(self, orignal_node, updated_node):
"""Replace imports that match our criteria."""
if m.matches(updated_node.body[0], m.ImportFrom()):
import_from = updated_node.body[0]
if m.matches(
import_from.module,
m.Attribute(value=m.Name('a'), attr=m.Name('b')),
):
if m.matches(
import_from.names[0],
m.ImportAlias(name=m.Name('foo_method')),
):
# Note that when matching we use m.Node,
# but when replacing we use cst.Node.
return updated_node.with_changes(
body=[
cst.ImportFrom(
module=cst.Attribute(
value=cst.Name('b'), attr=cst.Name('d')
),
names=[
cst.ImportAlias(
name=cst.Name('bar_method')
)
],
)
]
)
return updated_node
def leave_Call(self, original_node, updated_node):
if m.matches(updated_node, m.Call(func=m.Name('foo_method'))):
return updated_node.with_changes(func=cst.Name('bar_method'))
return updated_node
source_tree = cst.parse_module(src)
transformer = ImportFixer()
modified_tree = source_tree.visit(transformer)
print(modified_tree.code)
输出：
import foo
from b.d import bar_method
class C:
def do_something(self, x):
return bar_method(x)
libcst 的 解析辅助工具 来查看和处理模块、语句和表达式的节点树。这通常是确定要转换哪些节点以及需要匹配哪些内容的最佳方式。
libcst 提供了一个名为 codemods 的框架，以支持重构大型代码库。
import a.b; foo = a.b.foo_method这样的东西不存在？或者getattr(a.b, 'foo_method')？或者调用exec？ - a_guestImportError和AttributeError。然后可以使用这些信息来更新相应的文件，或者至少通知开发人员进行更新。当然，剩下的用法不应该太多，否则这将是非常计算密集型的。否则，您还可以尝试ast解析以识别重构的可能候选项。 - a_guest