製作整個名稱空間的副本？

Question

我想製作一個完整的命名空間的副本，同時用動態構建的版本替換一些函數。

換句話說，從名稱空間（import tensorflow as tf）開始，我想複製它，用我自己的版本替換一些函數，並更新所有符號的__globals__以保留在新的名稱空間中。這需要按照依賴關係的拓撲順序來完成。

我開始做類似here但現在我開始懷疑我是否在重新發明輪子。需要注意處理系統模塊中的循環依賴關係，功能/類型/對象需要以不同方式進行更新等。

任何人都可以指向解決類似任務的現有代碼嗎？

Answer 1

要導入一組函數，同時導入一組函數的第二個實例，您可以覆蓋標準的Python導入掛鉤並在導入時直接應用這些修補程序。這將確保任何其他模塊都不會看到任何模塊的未打補丁版本，所以即使他們直接按名稱從另一個模塊導入函數，他們也只會看到已打補丁的函數。這是證明了概念的實現：

import __builtin__ 
import collections 
import contextlib 
import sys 


@contextlib.contextmanager 
def replace_import_hook(new_import_hook): 
    original_import = __builtin__.__import__ 
    __builtin__.__import__ = new_import_hook 
    yield original_import 
    __builtin__.__import__ = original_import 


def clone_modules(patches, additional_module_names=None): 
    """Import new instances of a set of modules with some objects replaced. 

    Arguments: 
     patches - a dictionary mapping `full.module.name.symbol` to the new object. 
     additional_module_names - a list of the additional modules you want new instances of, without 
      replacing any objects in them. 

    Returns: 
     A dictionary mapping module names to the new patched module instances. 
    """ 

    def import_hook(module_name, *args): 
     result = original_import(module_name, *args) 
     if module_name not in old_modules or module_name in new_modules: 
      return result 
     # The semantics for the return value of __import__() are a bit weird, so we need some logic 
     # to determine the actual imported module object. 
     if len(args) >= 3 and args[2]: 
      module = result 
     else: 
      module = reduce(getattr, module_name.split('.')[1:], result) 
     for symbol, obj in patches_by_module[module_name].items(): 
      setattr(module, symbol, obj) 
     new_modules[module_name] = module 
     return result 

    # Group patches by module name 
    patches_by_module = collections.defaultdict(dict) 
    for dotted_name, obj in patches.items(): 
     module_name, symbol = dotted_name.rsplit('.', 1) # Only allows patching top-level objects 
     patches_by_module[module_name][symbol] = obj 

    try: 
     # Remove the old module instances from sys.modules and store them in old_modules 
     all_module_names = list(patches_by_module) 
     if additional_module_names is not None: 
      all_module_names.extend(additional_module_names) 
     old_modules = {} 
     for name in all_module_names: 
      old_modules[name] = sys.modules.pop(name) 

     # Re-import modules to create new patched versions 
     with replace_import_hook(import_hook) as original_import: 
      new_modules = {} 
      for module_name in all_module_names: 
       import_hook(module_name) 
    finally: 
     sys.modules.update(old_modules) 
    return new_modules 

在這裏，這個實現一些測試代碼：

from __future__ import print_function 

import math 
import random 

def patched_log(x): 
    print('Computing log({:g})'.format(x)) 
    return math.log(x) 

patches = {'math.log': patched_log} 
cloned_modules = clone_modules(patches, ['random']) 
new_math = cloned_modules['math'] 
new_random = cloned_modules['random'] 
print('Original log:   ', math.log(2.0)) 
print('Patched log:   ', new_math.log(2.0)) 
print('Original expovariate: ', random.expovariate(2.0)) 
print('Patched expovariate: ', new_random.expovariate(2.0)) 

測試代碼有這樣的輸出：

Computing log(4) 
Computing log(4.5) 
Original log:   0.69314718056 
Computing log(2) 
Patched log:   0.69314718056 
Original expovariate: 0.00638038735379 
Computing log(0.887611) 
Patched expovariate: 0.0596108277801 

前兩個來自these two lines in random的輸出結果行在輸入時執行。這表明random立即看到了修補功能。其餘輸出表明原始的math和random仍然使用未修補的版本log，而克隆的模塊都使用修補版本。

覆蓋進口鉤可能是使用一個元進口吊鉤在PEP 302定義，而是提供了一個全面推行這一做法的的更清潔的方式是超越的StackOverflow的範圍。

Answer 2

在我看來，你可以很容易地做到這一點：

import imp, string 

st = imp.load_module('st', *imp.find_module('string')) # copy the module 

def my_upper(a): 
    return "a" + a 

def my_lower(a): 
    return a + "a" 

st.upper = my_upper 
st.lower = my_lower 


print string.upper("hello") # HELLO 
print string.lower("hello") # hello 

print st.upper("hello") # ahello 
print st.lower("hello") # helloa 

當你罵st.upper("hello")，它會導致"hello"。

所以，你並不需要混淆全局。

Answer 3

與其試圖製作模塊內容的副本並將其中的所有內容修補爲使用正確的全局變量，可能會誘騙Python導入您想要第二次複製的所有內容。這將爲您提供所有模塊的新初始化副本，因此它不會複製模塊可能具有的任何全局狀態（不確定是否需要這樣做）。

import importlib 
import sys 

def new_module_instances(module_names): 
    old_modules = {} 
    for name in module_names: 
     old_modules[name] = sys.modules.pop(name) 
    new_modules = {} 
    for name in module_names: 
     new_modules[name] = importlib.import_module(name) 
    sys.modules.update(old_modules) 
    return new_modules 

請注意，我們先刪除我們想要從sys.modules取代所有模塊，所以他們都得到導入第二次，而這些模塊之間的依賴關係自動正確設置。在函數結束時，我們恢復原始狀態sys.modules，所以其他一切都繼續看到這些模塊的原始版本。

下面是一個例子：

>>> import logging.handlers 
>>> new_modules = new_module_instances(['logging', 'logging.handlers']) 
>>> logging_clone = new_modules['logging'] 
>>> logging 
<module 'logging' from '/usr/lib/python2.7/logging/__init__.pyc'> 
>>> logging_clone 
<module 'logging' from '/usr/lib/python2.7/logging/__init__.pyc'> 
>>> logging is logging_clone 
False 
>>> logging is logging.handlers.logging 
True 
>>> logging_clone is logging_clone.handlers.logging 
True 

最後三個表達式顯示，記錄的兩個版本不同的模塊，而模塊handlers兩個版本使用logging模塊的正確版本。