Every line of 'python import module from different directory' code snippets is scanned for vulnerabilities by our powerful machine learning engine that combs millions of open source libraries, ensuring your Python code is secure.
69 def _import_from(mod, path, mod_dir=None): 70 """ 71 Imports a module from a specific path 72 73 :param mod: 74 A unicode string of the module name 75 76 :param path: 77 A unicode string to the directory containing the module 78 79 :param mod_dir: 80 If the sub directory of "path" is different than the "mod" name, 81 pass the sub directory as a unicode string 82 83 :return: 84 None if not loaded, otherwise the module 85 """ 86 87 if mod_dir is None: 88 mod_dir = mod 89 90 if not os.path.exists(path): 91 return None 92 93 if not os.path.exists(os.path.join(path, mod_dir)): 94 return None 95 96 try: 97 mod_info = imp.find_module(mod_dir, [path]) 98 return imp.load_module(mod, *mod_info) 99 except ImportError: 100 return None
4 def import_dir(name, fromlist=()): 5 PACKAGE_EXT = '.sublime-package' 6 dirname = os.path.basename(os.path.dirname(os.path.realpath(__file__))) 7 if dirname.endswith(PACKAGE_EXT): 8 dirname = dirname[:-len(PACKAGE_EXT)] 9 return __import__('{0}.{1}'.format(dirname, name), fromlist=fromlist)
90 def __import__(name, globals=None, locals=None, fromlist=None): 91 """An alternative to the import function so that we can import 92 modules defined as strings. 93 94 This code was taken from: http://docs.python.org/lib/examples-imp.html 95 """ 96 # Fast path: see if the module has already been imported. 97 try: 98 return sys.modules[name] 99 except KeyError: 100 pass 101 102 # If any of the following calls raises an exception, 103 # there's a problem we can't handle -- let the caller handle it. 104 module_name = name.split('.')[-1] 105 module_path = os.path.join(EXAMPLE_DIR, *name.split('.')[:-1]) 106 107 fp, pathname, description = imp.find_module(module_name, [module_path]) 108 109 try: 110 return imp.load_module(module_name, fp, pathname, description) 111 finally: 112 # Since we may exit via an exception, close fp explicitly. 113 if fp: 114 fp.close()
51 def import_modules_from_package(package): 52 """Import modules from package and append into sys.modules 53 54 :param package: Full package name. For example: rally.plugins.openstack 55 """ 56 path = [os.path.dirname(rally.__file__), ".."] + package.split(".") 57 path = os.path.join(*path) 58 for root, dirs, files in os.walk(path): 59 for filename in files: 60 if filename.startswith("__") or not filename.endswith(".py"): 61 continue 62 new_package = ".".join(root.split(os.sep)).split("....")[1] 63 module_name = "%s.%s" % (new_package, filename[:-3]) 64 if module_name not in sys.modules: 65 sys.modules[module_name] = importlib.import_module(module_name)
4 def import_path(path): 5 path = os.path.abspath(path) 6 path, file = os.path.split(path) 7 file, ext = os.path.splitext(file) 8 sys.path.append(path) 9 module = __import__(file) 10 sys.path.pop() 11 return module
56 def _import_module(importer, module_name, package): 57 """Import a module dynamically into a package. 58 59 :param importer: PEP302 Importer object (which knows the path to look in). 60 :param module_name: the name of the module to import. 61 :param package: the package to import the module into. 62 """ 63 64 # Duplicate copies of modules are bad, so check if this has already been 65 # imported statically 66 if module_name in sys.modules: 67 return sys.modules[module_name] 68 69 loader = importer.find_module(module_name) 70 if loader is None: 71 return None 72 73 module = loader.load_module(module_name) 74 75 # Make this accessible through the parent package for static imports 76 local_name = module_name.partition(package.__name__ + '.')[2] 77 module_components = local_name.split('.') 78 parent = functools.reduce(getattr, module_components[:-1], package) 79 setattr(parent, module_components[-1], module) 80 81 return module
23 def import_from_directory(library, path): 24 """Import a library from a directory outside the path. 25 26 Parameters 27 ---------- 28 library: string 29 The name of the library. 30 path: string 31 The path of the folder containing the library. 32 33 """ 34 try: 35 return importlib.import_module(library) 36 except ImportError: 37 module_path = os.path.abspath(path) 38 version = sys.version_info 39 40 if version.major == 2: 41 f, filename, desc = imp.find_module(library, [module_path]) 42 return imp.load_module(library, f, filename, desc) 43 else: 44 sys.path.append(module_path) 45 return importlib.import_module(library)
19 def _importfrom(modname): 20 # from .edenscmnative import (where . is looked through this module) 21 fakelocals = {} 22 pkg = __import__("edenscmnative", globals(), fakelocals, [modname], level=0) 23 try: 24 fakelocals[modname] = mod = getattr(pkg, modname) 25 except AttributeError: 26 raise ImportError(r"cannot import name %s" % modname) 27 # force import; fakelocals[modname] may be replaced with the real module 28 getattr(mod, r"__doc__", None) 29 return fakelocals[modname]
69 def import_module(module_name): 70 ''' 71 Imports the specified module by name. 72 ''' 73 74 parts = module_name.split('.') 75 module = __import__(module_name) 76 for part in parts[1:]: 77 module = getattr(module, part) 78 return module
32 def import_module(path): 33 dirpath, mod_file = os.path.split(path) 34 mod_name = os.path.splitext(mod_file)[0] 35 full_name = os.path.splitext(path)[0] 36 #if os.path.exists(os.path.join(dirpath, '__init__.py')): 37 # dirpath = os.path.join(dirpath, '__init__.py') 38 39 if dirpath: 40 info = imp.find_module(mod_name, [dirpath]) 41 else: 42 info = imp.find_module(mod_name) 43 return imp.load_module(full_name, *info)