मल्टीप्रोसेसिंग मॉड्यूल में प्रति प्रक्रिया एक पायथन मॉड्यूल को दोबारा लोड करना

Question

क्या पाइथन के मल्टीप्रोसेसिंग मॉड्यूल का उपयोग करके बनाई गई प्रक्रियाओं में मॉड्यूल की प्रति-प्रक्रिया प्रतियों को लोड करने का कोई तरीका है? मैंने यह कोशिश की:

def my_fn(process_args): 
    import my_module 
    my_func() 

... लेकिन my_module में उप-आयात एक बार और सभी के लिए लोड और कैश हो जाते हैं। विशेष रूप से, उप-आयात में से एक कॉन्फ़िगरेशन फ़ाइल पढ़ता है जिसका मूल्य पहली प्रक्रिया के वातावरण के आधार पर सेट हो जाता है। यदि मैं इसे आजमाता हूं:

def my_fn(process_args): 
    try: 
     my_module = reload(my_module) 
    except NameError: 
     import my_module 

... my_module के उप-आयात को पुनः लोड नहीं किया जाता है। इस तरह

def my_realod(): 
try: 
    my_sub_module = reload(my_sub_module) 
except NameError: 
    import my_sub_module 

कॉल my_reload:

Answer 1

my_module में एक समारोह रखो, उदाहरण के लिए

def my_fn(process_args): 
try: 
    my_module = reload(my_module) 
    my_module.my_reload() 

except NameError: 
    import my_module 

Answer 2

आपने मॉड्यूल निरीक्षण द्वारा एक गहरी पुनः लोड समारोह को लागू फिर से लोड करने और पुन: लोड किसी भी मॉड्यूल की कोशिश कर सकते यह उपयोगकर्ता है। यह मूर्खतापूर्ण नहीं है, उदाहरण के लिए कुछ ऐसा नहीं होगा:

class MyClass: 
    module = import_module('amodule') 

लेकिन आपके उद्देश्यों के लिए पर्याप्त अच्छा हो सकता है।

mymod.py

# Example submodule to re-import 
print('import module mymod') 

# demonstrate we can even import test as a module and it works 
import sys 
from test import deep_reload_module 

value = 2 

def a_function(): 
    pass 

class XYZ: 
    pass 

class NewClass(object): 
    pass 

test.py

import importlib 
import sys 
import mymod 


def deep_reload_module(name): 

    mod = sys.modules.get(name) 
    if not mod: 
     importlib.import_module(name) 
     return 

    def get_mods_to_reload_recursively(name, modules_to_reload=None): 
     modules_to_reload = modules_to_reload or set() 
     mod = sys.modules[name] 
     modules_to_reload.add(name) 

     # loop through the attributes in this module and remember any 
     # submodules we should also reload 
     for attr in dir(mod): 
      prop = getattr(mod, attr) 
      if isinstance(prop, type(mymod)): 
       modname = attr 
      elif hasattr(prop, '__module__'): 
       modname = prop.__module__ 
       if not modname: 
        continue 
      else: 
       # this thing is not a module nor does it come from another 
       # module, so nothing to reimport. 
       continue 

      if modname in sys.builtin_module_names: 
       # probably best not to reimport built-ins... 
       continue 

      if modname in modules_to_reload: 
       # this is already marked for reimporting, so avoid infinite 
       # recursion 
       continue 

      # get_mods_to_reload... will update modules_to_reload so no need to 
      # catch the return value 
      get_mods_to_reload_recursively(modname, modules_to_reload) 

     return modules_to_reload 

    mods_to_reload = get_mods_to_reload_recursively(name) 
    for mtr in mods_to_reload: 
     # best to delete everything before reloading so that you are 
     # sure things get re-hooked up properly to the new modules. 
     print('del sys.modules[%s]' % (mtr,)) 
     del sys.modules[mtr] 

    importlib.import_module(name) 


if __name__ == '__main__': 
    orig_mymod_id = id(sys.modules['mymod']) 
    deep_reload_module('mymod') 
    assert orig_mymod_id != id(sys.modules['mymod']) 

तो फिर तुम बस जब भी एक नई प्रक्रिया शुरू होता है, या एक बहु काम की शुरुआत में और भी आसान deep_reload_module('module') कॉल करनी होगी।

एनबी: इस कोड कि मॉड्यूल आपने पहले कि मॉड्यूल से आयातित कुछ भी नहीं होने को फिर आयात, क्योंकि अगर यह तो है कि कोड वर्ष मॉड्यूल का उपयोग या तोड़ने के लिए जारी रहेगा चाहते बाहर रहता है पर काफी काफी निर्भर करता है।

उदा। यह करता है कि यदि आप कोड मिल गया है:

from module_to_reimport import a_function 

लेकिन कहीं भी स्पष्ट रूप से module_to_reimport बनाए रखा नहीं किया है, तो a_function अच्छी तरह से जब यह कहा जाता हो जाता है के बाद मॉड्यूल reimported है विफल हो सकता है, क्योंकि यह केवल globals() के लिए एक कमजोर संदर्भ का कहना है module_to_reimport में परिभाषित किया गया है और इन सभी को मॉड्यूल को sys.modules से हटाकर समाप्त कर दिया जाएगा।