Nhập khẩu một mô-đun python mà không thực sự thực thi nó

Question

Trong ngữ cảnh của một ứng dụng phức tạp, tôi cần phải nhập khẩu các tập lệnh 'do người dùng cung cấp'. Lý tưởng nhất, một kịch bản sẽ phải

def init(): 
    blah 

def execute(): 
    more blah 

def cleanup(): 
    yadda 

vì vậy tôi muốn chỉ

import imp 
fname, path, desc = imp.find_module(userscript) 
foo = imp.load_module(userscript, fname, path, desc) 
foo.init() 

Tuy nhiên, như chúng ta đều biết, kịch bản của người dùng là thực hiện càng sớm càng load_module chạy. Điều đó có nghĩa, một kịch bản có thể được một cái gì đó như thế này:

def init(): 
    blah 

yadda 

nhượng cho những phần yadda được gọi ngay sau khi tôi import kịch bản.

Những gì tôi cần là một cách để:

1. kiểm tra đầu tiên cho dù nó đã init(), thực hiện() và dọn dẹp()
2. nếu chúng tồn tại, tất cả là tốt
3. nếu họ don 't tồn tại, phàn nàn
4. không chạy bất kỳ mã khác, hoặc ít nhất là không cho đến khi tôi biết không có init()

Thông thường tôi sẽ buộc việc sử dụng các cũ if __name__ == '__main__' lừa, nhưng tôi có ít quyền kiểm soát trên tập lệnh do người dùng cung cấp, vì vậy tôi đang tìm một giải pháp tương đối không đau. Tôi đã thấy tất cả các loại thủ thuật phức tạp, bao gồm phân tích cú pháp kịch bản, nhưng không có gì thực sự đơn giản. Tôi ngạc nhiên vì nó không tồn tại .. hoặc có lẽ tôi không nhận được một cái gì đó.

Cảm ơn.

Answer 1

nỗ lực của tôi bằng cách sử dụng mô-đun ast:

import ast 

# which syntax elements are allowed at module level? 
whitelist = [ 
    # docstring 
    lambda x: isinstance(x, ast.Expr) \ 
      and isinstance(x.value, ast.Str), 
    # import 
    lambda x: isinstance(x, ast.Import), 
    # class 
    lambda x: isinstance(x, ast.ClassDef), 
    # function 
    lambda x: isinstance(x, ast.FunctionDef), 
] 

def validate(source, required_functions): 
    tree = ast.parse(source) 

    functions = set() 
    required_functions = set(required_functions) 

    for item in tree.body: 
    if isinstance(item, ast.FunctionDef): 
     functions.add(item.name) 
     continue 

    if all(not checker(item) for checker in whitelist): 
     return False 

    # at least the required functions must be there 
    return len(required_functions - functions) == 0 


if __name__ == "__main__": 
    required_funcs = [ "init", "execute", "cleanup" ] 
    with open("/tmp/test.py", "rb") as f: 
    print("yay!" if validate(f.read(), required_funcs) else "d'oh!") 

Answer 2

Một giải pháp rất đơn giản có thể là để kiểm tra các ký tự đầu tiên của mỗi dòng mã: Các phép chỉ nên là:

• def init():
• def execute():
• def cleanup():
• dòng bắt đầu với 4 không gian
• [tùy chọn]: các dòng bắt đầu bằng #

này rất thô sơ nhưng nó đáp ứng yêu cầu của bạn ...

Cập nhật: Sau một giây dù về nó tôi nhận ra rằng nó không phải là dễ dàng như vậy sau khi tất cả. Ví dụ: xem xét ví dụ về đoạn mã này:

def init(): 
    v = """abc 
def 
ghi""" 
    print(v) 

Điều này có nghĩa là bạn cần một thuật toán phân tích cú pháp mã phức tạp hơn ... nên quên giải pháp của tôi ...

Answer 3

Không chắc chắn nếu bạn sẽ xem xét thanh lịch này, nhưng nó là một chút thông minh theo nghĩa là nó nhận ra khi def init là thẻ và không chỉ là một phần của một chuỗi nhiều đường phức tạp:

''' 
def init does not define init... 
''' 

Nó sẽ không nhận ra khi init được định nghĩa theo nhiều cách khéo léo xen kẽ như

init = lambda ... 

hoặc

codestr='def i'+'nit ...' 
exec(codestr) 

Cách duy nhất để xử lý tất cả các trường hợp như vậy là chạy mã (ví dụ: trong hộp cát hoặc bằng cách nhập) và kiểm tra kết quả.

---

import tokenize 
import token 
import io 
import collections 

userscript = '''\ 
def init(): 
    blah 

""" 
def execute(): 
    more blah 
""" 

yadda 
''' 

class Token(object): 
    def __init__(self, tok): 
     toknum, tokval, (srow, scol), (erow, ecol), line = tok 
     self.toknum = toknum 
     self.tokname = token.tok_name[toknum] 
     self.tokval = tokval 
     self.srow = srow 
     self.scol = scol 
     self.erow = erow 
     self.ecol = ecol 
     self.line = line  

class Validator(object): 
    def __init__(self, codestr): 
     self.codestr = codestr 
     self.toks = collections.deque(maxlen = 2) 
     self.names = set() 
    def validate(self): 
     tokens = tokenize.generate_tokens(io.StringIO(self.codestr).readline) 
     self.toks.append(Token(next(tokens))) 
     for tok in tokens: 
      self.toks.append(Token(tok))    
      if (self.toks[0].tokname == 'NAME'  # First token is a name 
       and self.toks[0].scol == 0   # First token starts at col 0 
       and self.toks[0].tokval == 'def' # First token is 'def' 
       and self.toks[1].tokname == 'NAME' # Next token is a name 
       ): 
       self.names.add(self.toks[1].tokval) 
     delta = set(['init', 'cleanup', 'execute']) - self.names 
     if delta: 
      raise ValueError('{n} not defined'.format(n = ' and '.join(delta))) 

v = Validator(userscript) 
v.validate() 

mang

ValueError: execute and cleanup not defined 

Answer 4

Một giải pháp cho 1-3, (không phải là phần yadda) là để tay ra "generic_class.py" với tất cả các phương pháp mà bạn cần. Vì vậy,

class Generic(object): 

    def __init__(self): 
     return 

    def execute(self): 
     return 

    # etc 

Sau đó, bạn có thể kiểm tra sự tồn tại của "chung" trong những gì bạn đã nhập. Nếu nó không tồn tại, bạn có thể bỏ qua nó và nếu nó không thì bạn biết chính xác những gì ở đó. Bất cứ điều gì thêm sẽ không bao giờ được gọi trừ khi nó được gọi từ bên trong một trong các phương pháp được xác định trước của bạn.

Answer 5

tôi muốn trước hết là không đòi hỏi một số chức năng, nhưng một lớp học phù hợp với một giao diện cụ thể, sử dụng các mô-đun abc, hoặc zope.interface. Điều này buộc các nhà sản xuất của các mô-đun để cung cấp các chức năng mà bạn muốn.

Thứ hai, tôi sẽ không bận tâm tìm kiếm mã cấp mô-đun. Đó là vấn đề của người tạo mô-đun nếu anh ta làm điều này. Đó là quá nhiều công việc không có lợi ích thực tế.

Nếu bạn lo lắng về các vấn đề bảo mật, bạn cần phải sandbox mã bằng cách nào đó.

Answer 6

Dưới đây là một đơn giản hơn (và ngây thơ hơn) thay thế cho phương pháp AST:

import sys 
from imp import find_module, new_module, PY_SOURCE 


EXPECTED = ("init", "execute", "cleanup") 

def import_script(name): 
    fileobj, path, description = find_module(name) 

    if description[2] != PY_SOURCE: 
     raise ImportError("no source file found") 

    code = compile(fileobj.read(), path, "exec") 

    expected = list(EXPECTED) 
    for const in code.co_consts: 
     if isinstance(const, type(code)) and const.co_name in expected: 
      expected.remove(const.co_name) 
    if expected: 
     raise ImportError("missing expected function: {}".format(expected)) 

    module = new_module(name) 
    exec(code, module.__dict__) 
    sys.modules[name] = module 
    return module 

Hãy nhớ, đây là một cách rất trực tiếp làm việc đó và làm hỏng tính phần mở rộng cho máy móc thiết bị nhập khẩu của Python.