编写带有修饰函数和导入的模块

Question

i have this code in a python file:

from dec import my_decorator
import asyncio

@my_decorator
async def simple_method(bar):  # , x, plc_name, var_name):
    print("Henlo from simple_method\npartent:{}".format(parent))
    return


@my_decorator
async def other_simple_meth(bar, value):
    print("Henlo from other_simple_meth:\t Val:{}".format(value))
    return


async def main():
    print("Start Module-Export")
    open('module_functions.py', 'a').close()
    # Write all decorated functions to modue_functions.py
    print("Functions in module_functions.py exported")
    while True:
        asyncio.sleep(2)
        print("z...z...Z...")

My goal is to write all decorated functions (inc. the import dependencies) into a second module file (here "module_functions.py"). My 'module_functions.py' file should look like this:

from dec import my_decorator
import asyncio

@my_decorator
async def simple_method(bar):  # , x, plc_name, var_name):
    print("Henlo from simple_method\npartent:{}".format(parent))
    return


@my_decorator
async def other_simple_meth(bar, value):
    print("Henlo from other_simple_meth:\t Val:{}".format(value))
    return

I know how to get references and names of a function, but not how to "copy/paste" the functioncode (incl. decorator and all dependencies) into a seperated file. Is this even possible?

EDIT : I know that pickle and dill exist, but this may not fullfill the goal. The problem is, that someone else may not know the order of the dumped file and loading them back may/will cause problem. As well it seems to be not possible to edit such loaded functions again.

Answer 1

I found a (not ideal, but ok) solution for my problems.

I) Find and write functions, coroutines etc. into a file ( works ):

Like @MisterMiyagi suspected, is the inspect module a good way to go. For the common stuff, it is possible with inspect.getsource() to get the code and write them into a file:

# List of wanted stuff    
func_list = [simple_method, meth_with_input, meth_with_input_and_output, func_myself] 

    with open('module_functions.py', 'a') as module_file:
        for func in func_list:
            try:
                module_file.write(inspect.getsource(func))
                module_file.write("\n")
            except:
                print("Error :( ")

II) But what about decorated stuff( seems to work )?

I) will not work for decorated stuff, it is just ignored without throwing an exception. What seems to be used is from functools import wraps . In many examples the @wraps decorator is added into the decorator class. This was not possible for me, but there is a good workaround:

@wraps(lambda: simple_method) #<---add wraps-decorator here
@my_decorator
async def simple_method(parent):  # , x, plc_name, var_name):
    print("Henlo from simple_method\npartent:{}".format(parent))
    return

Wraps can be placed above the original decorated method/class/function and it seems to behave like I want. Now we can add simple_method into the func_list of I).

III) What about the imports?

Well it seems to be quite tricky/impossible to actually read the dependencies of a function. My workaround is to drop all wanted imports into a class ( sigh ). This class can be throw into the func_list of I) and is written into the file.

EDIT: There is a cleaner way, which may works, after some modification, with I) and II) as well. The magic module is ast .

I have overwritten following:

class ImportVisitor(ast.NodeVisitor):

    def __init__(self, target):
        super().__init__()
        self.file_target = target

    "pick these special nodes via overwriting: visit_classname." \
    "classnames are listed in https://docs.python.org/3.6/library/ast.html#abstract-grammar"
    def visit_Import(self, node):
        "Overwrite func!"
        "Write all statements just with import like -  import ast into file_target"
        str = 'import '+', '.join(alias.name for alias in node.names)
        self.file_target.write(str+"\n")

    def visit_ImportFrom(self, node):
        "Overwrite func!"
        "Write all statements with from ... import (like - from os.path import basename) into file_tagrget"
        str = 'from '+ node.module+ ' import '+', '.join(alias.name for alias in node.names)
        self.file_target.write(str+"\n")

Now I can parse my own script name and fill the module_file with the imports and from...imports it will find while visiting all nodes in this tree:

    with open('module_functions.py', 'a') as module_file:
        with open(basename(__file__), "rb") as f:
            tree = ast.parse(f.read(), basename(__file__))
            visitor = ImportVisitor(module_file)
            visitor.visit(tree)
            module_file.write("\n\n")