1 # Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
3 # Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 # This library is free software; you can redistribute it and/or
7 # modify it under the terms of the GNU Lesser General Public
8 # License as published by the Free Software Foundation; either
9 # version 2.1 of the License.
11 # This library is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # Lesser General Public License for more details.
16 # You should have received a copy of the GNU Lesser General Public
17 # License along with this library; if not, write to the Free Software
18 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 This module replaces the standard import mechanism with one
24 that filters some imports that can't be done more than once.
26 This is related to the multi study feature that is implemented
27 by using the Python multi interpreter feature.
28 Some modules register objects or classes by calling modules
29 implemented in C. These operations can't be done multiple times.
30 So it's very important to control these imports.
33 - PyQt : import qt calls a C module to register classes
34 - OmniORB : import *_idl calls a C module to register CORBA interfaces
37 - First import the module : import import_hook. This module will
38 replace the original importer mechanism
40 - Next register the module names or pattern names to filter out::
41 import_hook.register_name("a")
42 import_hook.register_pattern(pattern)
44 where pattern is a function with one parameter, the module name
45 to be imported, that returns true or false depending if this module is
46 to be filtered or not.
50 IMPORTANT : Every subinterpretor has its own import_hook module. import_hook is not shared among subinterpretors.
51 The mechanism only works if shared_imported and pattern are shared between all subinterpretors.
52 This is done by calling init_shared_modules().
55 import sys, imp, __builtin__
57 # Keep in shared_imported a copy of dictionnary modules
58 # that need to be imported only once in multi-study context
61 # patterns contains functions that returns 1 or 0 depending if
62 # the module name (argument) must be filtered out or not
63 # These functions are added by calling register_pattern
66 original_import=__builtin__.__import__
68 def register_name(name):
69 if shared_imported.has_key(name):return
70 shared_imported[name]=None
72 def register_pattern(pattern):
73 patterns.append(pattern)
76 """ Indicate if module name is a shared module
77 among multiple interpreters (return value=1)
79 if shared_imported.has_key(name):return 1
80 for pattern in patterns:
81 if pattern(name) : return 1
84 def get_shared_imported(name,fromlist):
85 """ If the module is registered in shared_imported
86 update the sys.modules dict
87 Let the real import be done by original_import
89 module= shared_imported.get(name)
91 #module name is not shared or not already imported
92 #let original_import do the job
95 # module is already imported and shared. Put it in sys.modules and
96 # let original_import finish the job
97 sys.modules[name]=module
99 def get_real_module(mod,name):
100 """Return effective module on import
101 Standard import returns module A on import A.B
102 To get module A.B use get_real_module with name "A.B"
104 components = name.split('.')
105 for comp in components[1:]:
106 mod = getattr(mod, comp)
109 def set_shared_imported(name,module):
110 """ Register a shared module
111 Name can be a dotted name : package
113 shared_imported[name]=module
114 #print "Module %s shared registered" % name,module
116 def import_module(partname, fqname, parent):
117 """ Try to import module fqname
118 It's parent is module parent and has name partname
121 m = sys.modules[fqname]
127 def ensure_fromlist(m, fromlist, recursive=0):
128 """ Return the real modules list to be imported
136 except AttributeError:
139 l.extend(ensure_fromlist(m, all, 1))
141 submod=getattr(m,sub)
142 if type(submod) == type(sys):
143 l.append(("%s.%s" % (m.__name__, sub),submod))
145 subname="%s.%s" % (m.__name__, sub)
146 submod = import_module(sub, subname, m)
148 raise ImportError, "No module named " + subname
149 l.append((subname,submod))
152 def import_hook(name, globals=None, locals=None, fromlist=None, *args):
153 """ Import replacement for sharing modules among multiple interpreters
154 Mostly update sys.modules before doing real import
156 #print "import_hook",name,fromlist
157 m=get_shared_imported(name,fromlist)
159 module= original_import(name, globals, locals, fromlist, *args)
162 #when fromlist is specified, module is the real module
163 #fromlist is a list of possibly dotted name
165 for nam,mod in ensure_fromlist(m, fromlist):
167 set_shared_imported(nam,mod)
169 #when fromlist is not specified and name is a dotted name,
170 # module is the root package not the real module
171 #so we need to retrieve it
172 # note: some modules like xml.dom do not play the rule
173 # (import xml: no attribute dom, but import xml.dom OK)
175 m=get_real_module(module,name)
176 except AttributeError:
179 if type(m) == type(sys) and is_shared(m.__name__):
180 set_shared_imported(m.__name__,m)
184 original_reload=__builtin__.reload
186 def reload_hook(module):
187 if is_shared(module.__name__):
189 return original_reload(module)
191 __builtin__.__import__=import_hook
192 # Reload is not replaced
193 #__builtin__.reload=reload_hook
195 def init_shared_modules(shared_module):
196 global shared_imported, patterns
197 shared_imported=shared_module.shared_imported
198 patterns= shared_module.patterns
199 for k,v in shared_imported.items():
200 if v is not None:sys.modules[k]=v
201 shared_imported["salome_shared_modules"]=shared_module
202 import salome_shared_modules
203 for m in salome_shared_modules.list_modules:
204 m.init_shared_modules()