8 examples of 'python import from parent folder' in Python

55
def _get_module_from_containing_folder(source_path, module_name):
56
    # module_name is a module directly inside source_path
57
    module = imp.load_source(module_name, source_path)
58
    return module

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()

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)

110
def import_it(self, partname, fqname, parent, force_load=0):
111
  if not partname:
112
    raise ValueError, "Empty module name"
113
  if not force_load:
114
    try:
115
      return self.modules[fqname]
116
    except KeyError:
117
      pass
118
  try:
119
    path = parent and parent.__path__
120
  except AttributeError:
121
    return None
122
  stuff = self.loader.find_module(partname, path)
123
  if not stuff:
124
    return None
125
  path = []
126
  for s in stuff[1:]:
127
    m = self.loader.load_module(fqname, s)
128
    if hasattr(m, '__path__'):
129
      path.extend(m.__path__)
130
  mod = self.loader.load_module(fqname, stuff[0])
131
  if hasattr(mod, '__path__'):
132
    mod.__path__.extend(path)
133
  else:
134
    mod.__path__ = path
135
  if parent:
136
    setattr(parent, partname, mod)
137
  return mod

32
def deep_import_hook(name, globals=None, locals=None, fromlist=None, level=-1):
33
    # For now level is ignored, it's just there to prevent crash  
34
    # with from __future__ import absolute_import
35
    parent = determine_parent(globals)
36
    q, tail = find_head_package(parent, name)
37
    m = load_tail(q, tail)
38
    if not fromlist:
39
        return q
40
    if hasattr(m, "__path__"):
41
        ensure_fromlist(m, fromlist)
42
    return m

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)

27
def my_import(name):
28
    """ dynamic importing """
29
    module, attr = name.rsplit('.', 1)
30
    mod = __import__(module, fromlist=[attr])
31
    klass = getattr(mod, attr)
32
    return klass()