Python 动态修改（运行时更新）
特性
- 实现函数运行时动态修改（开发的时候，非线上）
- 支持协程（tornado等）
- 兼容 python2， python3
安装
pip install realtimefunc
使用
from realtimefunc import realtimefunc
@coroutine
@realtimefunc
def test():
# function body
引言
后端服务的启动一般需要做相当多的准备工作， 导致启动的速度比较慢， 而在开发一项任务中很难做到一次性通过， 所以可能需要反复的重启服务， 这样相当的恼人。
另外， 接触一个 python 项目时， 当代码表示的逻辑难以理解， 或对代码表示的逻辑和实际效果有疑问的时候， 通常需要通过打印 log 的方式来理解， 或者通过 pdb 调试理解。
前者比较难以避免少打部分 log 而需要重启服务，后者功能强大但使用起来比较复杂，而且不能使当次修改，在下次调用及时生效（需要重启服务）。
备注:
很多web框架有自启动， 是通过检测项目文件的 mtime ， 然后替换掉当前的服务进程，比如 tornado 就是用一个定时器定时检测项目文件， 实现 autostart。但这种重启的是整个服务，所以费时并不会减少。
这样很自然的就会想到， 如果可以随时改动开发的代码， 而不需要重启整个服务，就舒服多了。
实现目标：
实现一个装饰器， 被装饰的函数任意修改，无需重启服务，再次调用时及时生效。
实现思路:
实现一个装饰器， 被装饰函数实际不会被调用， 只提供入口（被装饰函数）。 装饰器通过入口提供的信息， 找到入口定义源代码，获取最新的代码， 定义成一个当前作用域的内存函数。实际运行的则是这个内存函数。最新代码 realtimefunc
"""A decorator is used to update a function at runtime."""
from __future__ import print_function
import sys
import os
import re
import ast
import linecache
import functools
import traceback
from inspect import getfile, isclass, findsource, getblock
__all__ = ["realtimefunc"]
Decorator = "@realtimefunc"
PY3 = sys.version_info >= (3,)
# The cache
# record, used to record functions decorated by realtimefunc,
# is a dict {filename:{func1, func2}
# refresh, used to to mark functions which source file stat has changed,
# is also a dict {filename:{func1, func2}}
# Note: the filename may be repeated but it doesn't matter.
record = {}
refresh = {}
def _exec(code, filepath, firstlineno, glob, loc=None):
astNode = ast.parse(code)
astNode = ast.increment_lineno(astNode, firstlineno)
code = compile(astNode, filepath, 'exec')
exec(code, glob, loc)
def _findclass(func):
cls = sys.modules.get(func.__module__)
if cls is None:
return None
for name in func.__qualname__.split('.')[:-1]:
cls = getattr(cls, name)
if not isclass(cls):
return None
return cls
def get_qualname(func):
'''return qualname by look through the call stack.'''
qualname = []
stacks = traceback.extract_stack(f=None)
begin_flag = False
for stack in stacks[::-1]:
if stack[3].strip() == Decorator:
qualname.append(func.__name__)
begin_flag = True
if stack[2] == '<module>':
break
if begin_flag:
qualname.append(stack[2])
return '.'.join(qualname[::-1])
def get_func_real_firstlineno(func):
start_lineno = 0
lines = linecache.getlines(func.__code__.co_filename)
cls = _findclass(func)
if cls:
lines, lnum = findsource(cls)
lines = getblock(lines[lnum:])
start_lineno = lnum
# referenced from inspect _findclass
pat = re.compile(r'^(s*)defs*' + func.__name__ + r'')
candidates = []
for i in range(len(lines)):
match = pat.match(lines[i])
if match:
# if it's at toplevel, it's already the best one
if lines[i][0] == 'd':
return (i + start_lineno)
# else add whitespace to candidate list
candidates.append((match.group(1), i))
if candidates:
# this will sort by whitespace, and by line number,
# less whitespace first
candidates.sort()
return start_lineno + candidates[0][1]
else:
raise OSError('could not find function definition')
def get_source_code(func, func_runtime_name, firstlineno):
lines = linecache.getlines(func.__code__.co_filename)
code_lines = getblock(lines[firstlineno:])
# repalce function name
code_lines[0] = code_lines[0].replace(func.__name__, func_runtime_name, 1)
i_indent = code_lines[0].index("def")
# code indentation
code_lines = [line[i_indent:] for line in code_lines]
code = ''.join(code_lines)
return code
def check_file_stat(filename):
entry = linecache.cache.get(filename, None)
change = False
if not entry:
change = True
else:
size, mtime, _, fullname = entry
try:
stat = os.stat(fullname)
except OSError:
change = True
del linecache.cache[filename]
if size != stat.st_size or mtime != stat.st_mtime:
change = True
del linecache.cache[filename]
if change:
global refresh
for f in record[filename]:
refresh.setdefault(filename, set()).add(f)
def realtimefunc(func):
# python2 need set __qualname__ by hand
if not PY3:
func.__qualname__ = get_qualname(func)
func_real_name = func.__qualname__.replace('.', '_') + '_realfunc'
filename = getfile(func)
filepath = os.path.abspath(filename)
global record, refresh
record.setdefault(filename, set()).add(func)
refresh.setdefault(filename, set()).add(func)
@functools.wraps(func)
def wrapper(*args, **kwargs):
glob = func.__globals__
check_file_stat(filename)
if func in refresh[filename]:
firstlineno = get_func_real_firstlineno(func)
code_str = get_source_code(func, func_real_name, firstlineno)
_exec(code_str, filepath, firstlineno, glob)
refresh[filename].remove(func)
func_realtime = glob[func_real_name]
return func_realtime(*args, **kwargs)
return wrapper
效果
实现开发运行时修改函数， 可以很方便的查看和修改被装饰函数相关的数据，以及构造简单测试数据和进行简单的分支测试。
TODO
支持 log 打印， log 打印时， 显示的文件为 <string>， 行号也是相对的。已实现内存函数可以优化为只有在改动的时候重新定义，也就是可以做缓存。- 已实现