← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lazy_import.py

  • Committer: Patch Queue Manager
  • Date: 2011-10-14 16:54:26 UTC
  • mfrom: (6216.1.1 remove-this-file)
  • Revision ID: pqm@pqm.ubuntu.com-20111014165426-tjix4e6idryf1r2z
(jelmer) Remove an accidentally committed .THIS file. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/lazy_import.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
This includes waiting to import a module until it is actually used.
20
20
 
21
21
Most commonly, the 'lazy_import' function is used to import other modules
22
 
in an on-demand fashion. Typically use looks like:
 
22
in an on-demand fashion. Typically use looks like::
 
23
 
23
24
    from bzrlib.lazy_import import lazy_import
24
25
    lazy_import(globals(), '''
25
26
    from bzrlib import (
30
31
    import bzrlib.branch
31
32
    ''')
32
33
 
33
 
    Then 'errors, osutils, branch' and 'bzrlib' will exist as lazy-loaded
34
 
    objects which will be replaced with a real object on first use.
 
34
Then 'errors, osutils, branch' and 'bzrlib' will exist as lazy-loaded
 
35
objects which will be replaced with a real object on first use.
35
36
 
36
 
    In general, it is best to only load modules in this way. This is because
37
 
    it isn't safe to pass these variables to other functions before they
38
 
    have been replaced. This is especially true for constants, sometimes
39
 
    true for classes or functions (when used as a factory, or you want
40
 
    to inherit from them).
 
37
In general, it is best to only load modules in this way. This is because
 
38
it isn't safe to pass these variables to other functions before they
 
39
have been replaced. This is especially true for constants, sometimes
 
40
true for classes or functions (when used as a factory, or you want
 
41
to inherit from them).
41
42
"""
42
43
 
43
44
 
87
88
                          " to another variable?",
88
89
                extra=e)
89
90
        obj = factory(self, scope, name)
 
91
        if obj is self:
 
92
            raise errors.IllegalUseOfScopeReplacer(name, msg="Object tried"
 
93
                " to replace itself, check it's not using its own scope.")
90
94
        if ScopeReplacer._should_proxy:
91
95
            object.__setattr__(self, '_real_obj', obj)
92
96
        scope[name] = obj
94
98
 
95
99
    def _cleanup(self):
96
100
        """Stop holding on to all the extra stuff"""
97
 
        del self._factory
98
 
        del self._scope
 
101
        try:
 
102
            del self._factory
 
103
        except AttributeError:
 
104
            # Oops, we just lost a race with another caller of _cleanup.  Just
 
105
            # ignore it.
 
106
            pass
 
107
 
 
108
        try:
 
109
            del self._scope
 
110
        except AttributeError:
 
111
            # Another race loss.  See above.
 
112
            pass
 
113
 
99
114
        # We keep _name, so that we can report errors
100
115
        # del self._name
101
116
 
157
172
            None, indicating the module is being imported.
158
173
        :param children: Children entries to be imported later.
159
174
            This should be a map of children specifications.
160
 
            {'foo':(['bzrlib', 'foo'], None,
161
 
                {'bar':(['bzrlib', 'foo', 'bar'], None {})})
162
 
            }
163
 
        Examples:
 
175
            ::
 
176
            
 
177
                {'foo':(['bzrlib', 'foo'], None,
 
178
                    {'bar':(['bzrlib', 'foo', 'bar'], None {})})
 
179
                }
 
180
 
 
181
        Examples::
 
182
 
164
183
            import foo => name='foo' module_path='foo',
165
184
                          member=None, children={}
166
185
            import foo.bar => name='foo' module_path='foo', member=None,
367
386
def lazy_import(scope, text, lazy_import_class=None):
368
387
    """Create lazy imports for all of the imports in text.
369
388
 
370
 
    This is typically used as something like:
371
 
    from bzrlib.lazy_import import lazy_import
372
 
    lazy_import(globals(), '''
373
 
    from bzrlib import (
374
 
        foo,
375
 
        bar,
376
 
        baz,
377
 
        )
378
 
    import bzrlib.branch
379
 
    import bzrlib.transport
380
 
    ''')
 
389
    This is typically used as something like::
 
390
 
 
391
        from bzrlib.lazy_import import lazy_import
 
392
        lazy_import(globals(), '''
 
393
        from bzrlib import (
 
394
            foo,
 
395
            bar,
 
396
            baz,
 
397
            )
 
398
        import bzrlib.branch
 
399
        import bzrlib.transport
 
400
        ''')
381
401
 
382
402
    Then 'foo, bar, baz' and 'bzrlib' will exist as lazy-loaded
383
403
    objects which will be replaced with a real object on first use.