/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/lazy_import.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
21
21
Most commonly, the 'lazy_import' function is used to import other modules
22
22
in an on-demand fashion. Typically use looks like::
23
23
 
24
 
    from bzrlib.lazy_import import lazy_import
 
24
    from .lazy_import import lazy_import
25
25
    lazy_import(globals(), '''
26
 
    from bzrlib import (
 
26
    from breezy import (
27
27
        errors,
28
28
        osutils,
29
29
        branch,
30
30
        )
31
 
    import bzrlib.branch
 
31
    import breezy.branch
32
32
    ''')
33
33
 
34
 
Then 'errors, osutils, branch' and 'bzrlib' will exist as lazy-loaded
 
34
Then 'errors, osutils, branch' and 'breezy' will exist as lazy-loaded
35
35
objects which will be replaced with a real object on first use.
36
36
 
37
37
In general, it is best to only load modules in this way. This is because
154
154
        :param scope: The scope that objects should be imported into.
155
155
            Typically this is globals()
156
156
        :param name: The variable name. Often this is the same as the
157
 
            module_path. 'bzrlib'
 
157
            module_path. 'breezy'
158
158
        :param module_path: A list for the fully specified module path
159
 
            ['bzrlib', 'foo', 'bar']
 
159
            ['breezy', 'foo', 'bar']
160
160
        :param member: The member inside the module to import, often this is
161
161
            None, indicating the module is being imported.
162
162
        :param children: Children entries to be imported later.
163
163
            This should be a map of children specifications.
164
164
            ::
165
165
            
166
 
                {'foo':(['bzrlib', 'foo'], None,
167
 
                    {'bar':(['bzrlib', 'foo', 'bar'], None {})})
 
166
                {'foo':(['breezy', 'foo'], None,
 
167
                    {'bar':(['breezy', 'foo', 'bar'], None {})})
168
168
                }
169
169
 
170
170
        Examples::
206
206
 
207
207
        # Prepare the children to be imported
208
208
        for child_name, (child_path, child_member, grandchildren) in \
209
 
                children.iteritems():
 
209
                children.items():
210
210
            # Using self.__class__, so that children get children classes
211
211
            # instantiated. (This helps with instrumented tests)
212
212
            cls = object.__getattribute__(self, '__class__')
245
245
 
246
246
    def _convert_imports(self, scope):
247
247
        # Now convert the map into a set of imports
248
 
        for name, info in self.imports.iteritems():
 
248
        for name, info in self.imports.items():
249
249
            self._lazy_import_class(scope, name=name, module_path=info[0],
250
250
                                    member=info[1], children=info[2])
251
251
 
284
284
                module_path = as_hunks[0].strip().split('.')
285
285
                if name in self.imports:
286
286
                    raise errors.ImportNameCollision(name)
 
287
                if not module_path[0]:
 
288
                    raise ImportError(path)
287
289
                # No children available in 'import foo as bar'
288
290
                self.imports[name] = (module_path, None, {})
289
291
            else:
290
292
                # Now we need to handle
291
293
                module_path = path.split('.')
292
294
                name = module_path[0]
 
295
                if not name:
 
296
                    raise ImportError(path)
293
297
                if name not in self.imports:
294
298
                    # This is a new import that we haven't seen before
295
299
                    module_def = ([name], None, {})
321
325
 
322
326
        from_module_path = from_module.split('.')
323
327
 
 
328
        if not from_module_path[0]:
 
329
            raise ImportError(from_module)
 
330
 
324
331
        for path in import_list.split(','):
325
332
            path = path.strip()
326
333
            if not path:
377
384
 
378
385
    This is typically used as something like::
379
386
 
380
 
        from bzrlib.lazy_import import lazy_import
 
387
        from breezy.lazy_import import lazy_import
381
388
        lazy_import(globals(), '''
382
 
        from bzrlib import (
 
389
        from breezy import (
383
390
            foo,
384
391
            bar,
385
392
            baz,
386
393
            )
387
 
        import bzrlib.branch
388
 
        import bzrlib.transport
 
394
        import breezy.branch
 
395
        import breezy.transport
389
396
        ''')
390
397
 
391
 
    Then 'foo, bar, baz' and 'bzrlib' will exist as lazy-loaded
 
398
    Then 'foo, bar, baz' and 'breezy' will exist as lazy-loaded
392
399
    objects which will be replaced with a real object on first use.
393
400
 
394
401
    In general, it is best to only load modules in this way. This is
401
408
    return proc.lazy_import(scope, text)
402
409
 
403
410
 
404
 
# The only module that this module depends on is 'bzrlib.errors'. But it
 
411
# The only module that this module depends on is 'breezy.errors'. But it
405
412
# can actually be imported lazily, since we only need it if there is a
406
413
# problem.
407
414
 
408
415
lazy_import(globals(), """
409
 
from bzrlib import errors
 
416
from breezy import errors
410
417
""")