def _initialize_module(): """ A function to explicitly avoid polluting the global namespace """ def _get_lazy_attributes(local_lazy_attributes, l_module, l_data): template_names = [t[0] for t in l_data["templates"]] is_in_library = [t[3] for t in l_data["templates"] if len(t) > 3] local_attributes = dict([(n, l_module) for n in template_names]) attributes_in_module = dict( [(n, belongs) for n, belongs in zip(template_names, is_in_library)] ) items = local_attributes.items() for kk, vv in items: if is_in_library and attributes_in_module[kk] is True: local_lazy_attributes.setdefault(kk, []).insert(0, vv) else: local_lazy_attributes.setdefault(kk, []).append(vv) if "snake_case_functions" in l_data: for function in l_data["snake_case_functions"]: local_lazy_attributes.setdefault(function, []).append(l_module) return l_module, l_data import itkBase import itkConfig import itkLazy import itkTypes import itkExtras import os import sys this_module = sys.modules[__name__] if itkConfig.LazyLoading: # If we are loading lazily (on-demand), make a dict mapping the available # classes/functions/etc. (read from the configuration modules) to the # modules they are declared in. Then pass that dict to a LazyITKModule # instance and (later) do some surgery on sys.modules so that the 'itk' # module becomes that new instance instead of what is executed from this # file. lazy_attributes = {} for module, data in itkBase.itk_base_global_module_data.items(): _get_lazy_attributes(lazy_attributes, module, data) if isinstance(this_module, itkLazy.LazyITKModule): # Handle reload case where we've already done this once. # If we made a new module every time, multiple reload()s would fail # because the identity of sys.modules['itk'] would always be changing. this_module.__init__(__name__, lazy_attributes) del lazy_attributes else: this_module = itkLazy.LazyITKModule(__name__, lazy_attributes) else: # We're not lazy-loading. Just load the modules in the order specified in # the known_modules list for consistency. for module in itkBase.itk_base_global_known_modules: itkBase.itk_load_swig_module(module, this_module.__dict__) # Regardless of how it was loaded, fill up the itk module with the ITK types # and extras. for k, v in itkTypes.__dict__.items(): if k != "itkCType" and not k.startswith("_"): setattr(this_module, k, v) for k, v in itkExtras.__dict__.items(): if not k.startswith("_"): setattr(this_module, k, v) # Populate itk.ITKModuleName for module, data in itkBase.itk_base_global_module_data.items(): attributes = {} module, data = _get_lazy_attributes(attributes, module, data) itk_module = itkLazy.LazyITKModule(module, attributes) setattr(this_module, module, itk_module) # Set the __path__ attribute, which is required for this module to be used as a # package setattr(this_module, "__path__", __path__) setattr(this_module, "__spec__", __spec__) # pytype: disable=name-error if itkConfig.LazyLoading: # this has to be the last step, else python gets confused about itkTypes # and itkExtras above. I'm not sure why... sys.modules[__name__] = this_module else: # do some cleanup del module, this_module, itk_module del itkBase, itkConfig, itkLazy, itkTypes, itkExtras, os, sys
# modules they are declared in. Then pass that dict to a LazyITKModule # instance and (later) do some surgery on sys.modules so that the 'itk' # module becomes that new instance instead of what is executed from this file. lazyAttributes = {} for module, data in itkBase.module_data.items(): templateNames = [t[0] for t in data['templates']] attributes = dict([(n, module) for n in templateNames]) lazyAttributes.update(attributes) if isinstance(thisModule, itkLazy.LazyITKModule): # Handle reload case where we've already done this once. # If we made a new module every time, multiple reload()s would fail # because the identity of sys.modules['itk'] would always be changing. thisModule.__init__(__name__, lazyAttributes) del lazyAttributes else: thisModule = itkLazy.LazyITKModule(__name__, lazyAttributes) else: # We're not lazy-loading. Just load the modules in the order specified in # the known_modules list for consistency. for module in itkBase.known_modules: itkBase.LoadModule(module, thisModule.__dict__) # Regardless of how it was loaded, fill up the itk module with the ITK types # and extras. for k, v in itkTypes.__dict__.items(): if k != 'itkCType' and not k.startswith('_'): setattr(thisModule, k, v) for k, v in itkExtras.__dict__.items(): if not k.startswith('_'): setattr(thisModule, k, v)
def _initialize_module(): """ A function to explicitly avoid polluting the global namespace """ def _get_lazy_attributes(local_lazy_attributes, l_module, l_data): template_feature_tuples = [ (t[0], t[3]) if len(t) > 3 else (t[0], False) for t in l_data["templates"] ] for (template_name, is_in_library) in template_feature_tuples: if is_in_library: # insert in front front if in library local_lazy_attributes.setdefault(template_name, []).insert(0, l_module) else: # append to end local_lazy_attributes.setdefault(template_name, []).append(l_module) if "snake_case_functions" in l_data: for function in l_data["snake_case_functions"]: # snake case always appended to end local_lazy_attributes.setdefault(function, []).append(l_module) import itkBase import itkConfig import itkLazy import sys if itkConfig.LazyLoading: # If we are loading lazily (on-demand), make a dict mapping the available # classes/functions/etc. (read from the configuration modules) to the # modules they are declared in. Then pass that dict to a LazyITKModule # instance and (later) do some surgery on sys.modules so that the 'itk' # module becomes that new instance instead of what is executed from this # file. lazy_attributes = {} for module, data in itkBase.itk_base_global_module_data.items(): _get_lazy_attributes(lazy_attributes, module, data) if isinstance(sys.modules[__name__], itkLazy.LazyITKModule): # Handle reload case where we've already done this once. # If we made a new module every time, multiple reload()s would fail # because the identity of sys.modules['itk'] would always be changing. sys.modules[__name__].__init__(__name__, lazy_attributes) del lazy_attributes else: # Create a new LazyITKModule lzy_module = itkLazy.LazyITKModule(__name__, lazy_attributes) # Set the __path__ attribute, which is required for this_module # to be used as a package setattr(lzy_module, "__path__", __path__) setattr(lzy_module, "__spec__", __spec__) # pytype: disable=name-error # Now override the default sys.modules[__name__] (__name__ == 'itk' ) sys.modules[__name__] = lzy_module else: # We're not lazy-loading. Just load the modules in the order specified in # the known_modules list for consistency. for module in itkBase.itk_base_global_module_data.keys(): itkBase.itk_load_swig_module(module, sys.modules[__name__].__dict__) # Populate itk.ITKModuleName for module, data in itkBase.itk_base_global_module_data.items(): attributes = {} _get_lazy_attributes(attributes, module, data) itk_module = itkLazy.LazyITKModule(module, attributes) setattr(sys.modules[__name__], module, itk_module) # Regardless of how it was loaded, fill up the itk module with the ITK types # and extras. import itkTypes for k, v in itkTypes.__dict__.items(): if k != "itkCType" and not k.startswith("_"): setattr(sys.modules[__name__], k, v) del itkTypes import itkInitHelpers for k, v in itkInitHelpers.__dict__.items(): if not k.startswith("_"): setattr(sys.modules[__name__], k, v) del itkInitHelpers import itkExtras for k, v in itkExtras.__dict__.items(): if not k.startswith("_"): setattr(sys.modules[__name__], k, v) del itkExtras # -- # Needed to propagate symbol to itk.image from itkTemplate.image import itkTemplate setattr(sys.modules[__name__], "image", itkTemplate.image) setattr(sys.modules[__name__], "output", itkTemplate.output) del itkTemplate