← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/lazy_import.py

  • Committer: Florent Gallaire
  • Date: 2017-03-17 10:39:02 UTC
  • mto: This revision was merged to the branch mainline in revision 6622.
  • Revision ID: fgallaire@gmail.com-20170317103902-xsmafws9vn8rczx9
Fix for Windows and 32-bit platforms buggy gmtime().

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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Functionality to create lazy evaluation objects.
18
18
 
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
 
 
44
from __future__ import absolute_import
 
45
 
43
46
 
44
47
class ScopeReplacer(object):
45
48
    """A lazy object that will replace itself in the appropriate scope.
50
53
 
51
54
    __slots__ = ('_scope', '_factory', '_name', '_real_obj')
52
55
 
53
 
    # Setting this to True will allow you to do x = y, and still access members
54
 
    # from both variables. This should not normally be enabled, but is useful
55
 
    # when building documentation.
56
 
    _should_proxy = False
 
56
    # If you to do x = y, setting this to False will disallow access to
 
57
    # members from the second variable (i.e. x). This should normally
 
58
    # be enabled for reasons of thread safety and documentation, but
 
59
    # will be disabled during the selftest command to check for abuse.
 
60
    _should_proxy = True
57
61
 
58
62
    def __init__(self, scope, factory, name):
59
63
        """Create a temporary object in the specified scope.
64
68
            It will be passed (self, scope, name)
65
69
        :param name: The variable name in the given scope.
66
70
        """
67
 
        self._scope = scope
68
 
        self._factory = factory
69
 
        self._name = name
70
 
        self._real_obj = None
 
71
        object.__setattr__(self, '_scope', scope)
 
72
        object.__setattr__(self, '_factory', factory)
 
73
        object.__setattr__(self, '_name', name)
 
74
        object.__setattr__(self, '_real_obj', None)
71
75
        scope[name] = self
72
76
 
73
 
    def _replace(self):
74
 
        """Actually replace self with other in the given scope"""
 
77
    def _resolve(self):
 
78
        """Return the real object for which this is a placeholder"""
75
79
        name = object.__getattribute__(self, '_name')
76
 
        try:
 
80
        real_obj = object.__getattribute__(self, '_real_obj')
 
81
        if real_obj is None:
 
82
            # No obj generated previously, so generate from factory and scope.
77
83
            factory = object.__getattribute__(self, '_factory')
78
84
            scope = object.__getattribute__(self, '_scope')
79
 
        except AttributeError, e:
80
 
            # Because ScopeReplacer objects only replace a single
81
 
            # item, passing them to another variable before they are
82
 
            # replaced would cause them to keep getting replaced
83
 
            # (only they are replacing the wrong variable). So we
84
 
            # make it forbidden, and try to give a good error.
 
85
            obj = factory(self, scope, name)
 
86
            if obj is self:
 
87
                raise errors.IllegalUseOfScopeReplacer(name, msg="Object tried"
 
88
                    " to replace itself, check it's not using its own scope.")
 
89
 
 
90
            # Check if another thread has jumped in while obj was generated.
 
91
            real_obj = object.__getattribute__(self, '_real_obj')
 
92
            if real_obj is None:
 
93
                # Still no prexisting obj, so go ahead and assign to scope and
 
94
                # return. There is still a small window here where races will
 
95
                # not be detected, but safest to avoid additional locking.
 
96
                object.__setattr__(self, '_real_obj', obj)
 
97
                scope[name] = obj
 
98
                return obj
 
99
 
 
100
        # Raise if proxying is disabled as obj has already been generated.
 
101
        if not ScopeReplacer._should_proxy:
85
102
            raise errors.IllegalUseOfScopeReplacer(
86
 
                name, msg="Object already cleaned up, did you assign it"
87
 
                          " to another variable?",
88
 
                extra=e)
89
 
        obj = factory(self, scope, name)
90
 
        if ScopeReplacer._should_proxy:
91
 
            self._real_obj = obj
92
 
        scope[name] = obj
93
 
        return obj
94
 
 
95
 
    def _cleanup(self):
96
 
        """Stop holding on to all the extra stuff"""
97
 
        del self._factory
98
 
        del self._scope
99
 
        # We keep _name, so that we can report errors
100
 
        # del self._name
 
103
                name, msg="Object already replaced, did you assign it"
 
104
                          " to another variable?")
 
105
        return real_obj
101
106
 
102
107
    def __getattribute__(self, attr):
103
 
        obj = object.__getattribute__(self, '_real_obj')
104
 
        if obj is None:
105
 
            _replace = object.__getattribute__(self, '_replace')
106
 
            obj = _replace()
107
 
            _cleanup = object.__getattribute__(self, '_cleanup')
108
 
            _cleanup()
 
108
        obj = object.__getattribute__(self, '_resolve')()
109
109
        return getattr(obj, attr)
110
110
 
 
111
    def __setattr__(self, attr, value):
 
112
        obj = object.__getattribute__(self, '_resolve')()
 
113
        return setattr(obj, attr, value)
 
114
 
111
115
    def __call__(self, *args, **kwargs):
112
 
        _replace = object.__getattribute__(self, '_replace')
113
 
        obj = _replace()
114
 
        _cleanup = object.__getattribute__(self, '_cleanup')
115
 
        _cleanup()
 
116
        obj = object.__getattribute__(self, '_resolve')()
116
117
        return obj(*args, **kwargs)
117
118
 
118
119
 
 
120
def disallow_proxying():
 
121
    """Disallow lazily imported modules to be used as proxies.
 
122
 
 
123
    Calling this function might cause problems with concurrent imports
 
124
    in multithreaded environments, but will help detecting wasteful
 
125
    indirection, so it should be called when executing unit tests.
 
126
 
 
127
    Only lazy imports that happen after this call are affected.
 
128
    """
 
129
    ScopeReplacer._should_proxy = False
 
130
 
 
131
 
119
132
class ImportReplacer(ScopeReplacer):
120
133
    """This is designed to replace only a portion of an import list.
121
134
 
140
153
 
141
154
        :param scope: The scope that objects should be imported into.
142
155
            Typically this is globals()
143
 
        :param name: The variable name. Often this is the same as the 
 
156
        :param name: The variable name. Often this is the same as the
144
157
            module_path. 'bzrlib'
145
158
        :param module_path: A list for the fully specified module path
146
159
            ['bzrlib', 'foo', 'bar']
148
161
            None, indicating the module is being imported.
149
162
        :param children: Children entries to be imported later.
150
163
            This should be a map of children specifications.
151
 
            {'foo':(['bzrlib', 'foo'], None, 
152
 
                {'bar':(['bzrlib', 'foo', 'bar'], None {})})
153
 
            }
154
 
        Examples:
 
164
            ::
 
165
            
 
166
                {'foo':(['bzrlib', 'foo'], None,
 
167
                    {'bar':(['bzrlib', 'foo', 'bar'], None {})})
 
168
                }
 
169
 
 
170
        Examples::
 
171
 
155
172
            import foo => name='foo' module_path='foo',
156
173
                          member=None, children={}
157
174
            import foo.bar => name='foo' module_path='foo', member=None,
161
178
            from foo import bar, baz would get translated into 2 import
162
179
            requests. On for 'name=bar' and one for 'name=baz'
163
180
        """
164
 
        if member is not None:
165
 
            assert not children, \
166
 
                'Cannot supply both a member and children'
 
181
        if (member is not None) and children:
 
182
            raise ValueError('Cannot supply both a member and children')
167
183
 
168
 
        self._import_replacer_children = children
169
 
        self._member = member
170
 
        self._module_path = module_path
 
184
        object.__setattr__(self, '_import_replacer_children', children)
 
185
        object.__setattr__(self, '_member', member)
 
186
        object.__setattr__(self, '_module_path', module_path)
171
187
 
172
188
        # Indirecting through __class__ so that children can
173
189
        # override _import (especially our instrumented version)
181
197
        module_path = object.__getattribute__(self, '_module_path')
182
198
        module_python_path = '.'.join(module_path)
183
199
        if member is not None:
184
 
            module = __import__(module_python_path, scope, scope, [member])
 
200
            module = __import__(module_python_path, scope, scope, [member], level=0)
185
201
            return getattr(module, member)
186
202
        else:
187
 
            module = __import__(module_python_path, scope, scope, [])
 
203
            module = __import__(module_python_path, scope, scope, [], level=0)
188
204
            for path in module_path[1:]:
189
205
                module = getattr(module, path)
190
206
 
251
267
 
252
268
        :param import_str: The import string to process
253
269
        """
254
 
        assert import_str.startswith('import ')
 
270
        if not import_str.startswith('import '):
 
271
            raise ValueError('bad import string %r' % (import_str,))
255
272
        import_str = import_str[len('import '):]
256
273
 
257
274
        for path in import_str.split(','):
296
313
 
297
314
        :param from_str: The import string to process
298
315
        """
299
 
        assert from_str.startswith('from ')
 
316
        if not from_str.startswith('from '):
 
317
            raise ValueError('bad from/import %r' % from_str)
300
318
        from_str = from_str[len('from '):]
301
319
 
302
320
        from_module, import_list = from_str.split(' import ')
357
375
def lazy_import(scope, text, lazy_import_class=None):
358
376
    """Create lazy imports for all of the imports in text.
359
377
 
360
 
    This is typically used as something like:
361
 
    from bzrlib.lazy_import import lazy_import
362
 
    lazy_import(globals(), '''
363
 
    from bzrlib import (
364
 
        foo,
365
 
        bar,
366
 
        baz,
367
 
        )
368
 
    import bzrlib.branch
369
 
    import bzrlib.transport
370
 
    ''')
 
378
    This is typically used as something like::
 
379
 
 
380
        from bzrlib.lazy_import import lazy_import
 
381
        lazy_import(globals(), '''
 
382
        from bzrlib import (
 
383
            foo,
 
384
            bar,
 
385
            baz,
 
386
            )
 
387
        import bzrlib.branch
 
388
        import bzrlib.transport
 
389
        ''')
371
390
 
372
391
    Then 'foo, bar, baz' and 'bzrlib' will exist as lazy-loaded
373
392
    objects which will be replaced with a real object on first use.