/usr/lib/python2.7/dist-packages/bzrlib/lazy_import.py is in python-bzrlib 2.7.0-2ubuntu3.1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 | # Copyright (C) 2006-2010 Canonical Ltd
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
"""Functionality to create lazy evaluation objects.
This includes waiting to import a module until it is actually used.
Most commonly, the 'lazy_import' function is used to import other modules
in an on-demand fashion. Typically use looks like::
from bzrlib.lazy_import import lazy_import
lazy_import(globals(), '''
from bzrlib import (
errors,
osutils,
branch,
)
import bzrlib.branch
''')
Then 'errors, osutils, branch' and 'bzrlib' will exist as lazy-loaded
objects which will be replaced with a real object on first use.
In general, it is best to only load modules in this way. This is because
it isn't safe to pass these variables to other functions before they
have been replaced. This is especially true for constants, sometimes
true for classes or functions (when used as a factory, or you want
to inherit from them).
"""
from __future__ import absolute_import
class ScopeReplacer(object):
"""A lazy object that will replace itself in the appropriate scope.
This object sits, ready to create the real object the first time it is
needed.
"""
__slots__ = ('_scope', '_factory', '_name', '_real_obj')
# If you to do x = y, setting this to False will disallow access to
# members from the second variable (i.e. x). This should normally
# be enabled for reasons of thread safety and documentation, but
# will be disabled during the selftest command to check for abuse.
_should_proxy = True
def __init__(self, scope, factory, name):
"""Create a temporary object in the specified scope.
Once used, a real object will be placed in the scope.
:param scope: The scope the object should appear in
:param factory: A callable that will create the real object.
It will be passed (self, scope, name)
:param name: The variable name in the given scope.
"""
object.__setattr__(self, '_scope', scope)
object.__setattr__(self, '_factory', factory)
object.__setattr__(self, '_name', name)
object.__setattr__(self, '_real_obj', None)
scope[name] = self
def _resolve(self):
"""Return the real object for which this is a placeholder"""
name = object.__getattribute__(self, '_name')
real_obj = object.__getattribute__(self, '_real_obj')
if real_obj is None:
# No obj generated previously, so generate from factory and scope.
factory = object.__getattribute__(self, '_factory')
scope = object.__getattribute__(self, '_scope')
obj = factory(self, scope, name)
if obj is self:
raise errors.IllegalUseOfScopeReplacer(name, msg="Object tried"
" to replace itself, check it's not using its own scope.")
# Check if another thread has jumped in while obj was generated.
real_obj = object.__getattribute__(self, '_real_obj')
if real_obj is None:
# Still no prexisting obj, so go ahead and assign to scope and
# return. There is still a small window here where races will
# not be detected, but safest to avoid additional locking.
object.__setattr__(self, '_real_obj', obj)
scope[name] = obj
return obj
# Raise if proxying is disabled as obj has already been generated.
if not ScopeReplacer._should_proxy:
raise errors.IllegalUseOfScopeReplacer(
name, msg="Object already replaced, did you assign it"
" to another variable?")
return real_obj
def __getattribute__(self, attr):
obj = object.__getattribute__(self, '_resolve')()
return getattr(obj, attr)
def __setattr__(self, attr, value):
obj = object.__getattribute__(self, '_resolve')()
return setattr(obj, attr, value)
def __call__(self, *args, **kwargs):
obj = object.__getattribute__(self, '_resolve')()
return obj(*args, **kwargs)
def disallow_proxying():
"""Disallow lazily imported modules to be used as proxies.
Calling this function might cause problems with concurrent imports
in multithreaded environments, but will help detecting wasteful
indirection, so it should be called when executing unit tests.
Only lazy imports that happen after this call are affected.
"""
ScopeReplacer._should_proxy = False
class ImportReplacer(ScopeReplacer):
"""This is designed to replace only a portion of an import list.
It will replace itself with a module, and then make children
entries also ImportReplacer objects.
At present, this only supports 'import foo.bar.baz' syntax.
"""
# '_import_replacer_children' is intentionally a long semi-unique name
# that won't likely exist elsewhere. This allows us to detect an
# ImportReplacer object by using
# object.__getattribute__(obj, '_import_replacer_children')
# We can't just use 'isinstance(obj, ImportReplacer)', because that
# accesses .__class__, which goes through __getattribute__, and triggers
# the replacement.
__slots__ = ('_import_replacer_children', '_member', '_module_path')
def __init__(self, scope, name, module_path, member=None, children={}):
"""Upon request import 'module_path' as the name 'module_name'.
When imported, prepare children to also be imported.
:param scope: The scope that objects should be imported into.
Typically this is globals()
:param name: The variable name. Often this is the same as the
module_path. 'bzrlib'
:param module_path: A list for the fully specified module path
['bzrlib', 'foo', 'bar']
:param member: The member inside the module to import, often this is
None, indicating the module is being imported.
:param children: Children entries to be imported later.
This should be a map of children specifications.
::
{'foo':(['bzrlib', 'foo'], None,
{'bar':(['bzrlib', 'foo', 'bar'], None {})})
}
Examples::
import foo => name='foo' module_path='foo',
member=None, children={}
import foo.bar => name='foo' module_path='foo', member=None,
children={'bar':(['foo', 'bar'], None, {}}
from foo import bar => name='bar' module_path='foo', member='bar'
children={}
from foo import bar, baz would get translated into 2 import
requests. On for 'name=bar' and one for 'name=baz'
"""
if (member is not None) and children:
raise ValueError('Cannot supply both a member and children')
object.__setattr__(self, '_import_replacer_children', children)
object.__setattr__(self, '_member', member)
object.__setattr__(self, '_module_path', module_path)
# Indirecting through __class__ so that children can
# override _import (especially our instrumented version)
cls = object.__getattribute__(self, '__class__')
ScopeReplacer.__init__(self, scope=scope, name=name,
factory=cls._import)
def _import(self, scope, name):
children = object.__getattribute__(self, '_import_replacer_children')
member = object.__getattribute__(self, '_member')
module_path = object.__getattribute__(self, '_module_path')
module_python_path = '.'.join(module_path)
if member is not None:
module = __import__(module_python_path, scope, scope, [member], level=0)
return getattr(module, member)
else:
module = __import__(module_python_path, scope, scope, [], level=0)
for path in module_path[1:]:
module = getattr(module, path)
# Prepare the children to be imported
for child_name, (child_path, child_member, grandchildren) in \
children.iteritems():
# Using self.__class__, so that children get children classes
# instantiated. (This helps with instrumented tests)
cls = object.__getattribute__(self, '__class__')
cls(module.__dict__, name=child_name,
module_path=child_path, member=child_member,
children=grandchildren)
return module
class ImportProcessor(object):
"""Convert text that users input into lazy import requests"""
# TODO: jam 20060912 This class is probably not strict enough about
# what type of text it allows. For example, you can do:
# import (foo, bar), which is not allowed by python.
# For now, it should be supporting a superset of python import
# syntax which is all we really care about.
__slots__ = ['imports', '_lazy_import_class']
def __init__(self, lazy_import_class=None):
self.imports = {}
if lazy_import_class is None:
self._lazy_import_class = ImportReplacer
else:
self._lazy_import_class = lazy_import_class
def lazy_import(self, scope, text):
"""Convert the given text into a bunch of lazy import objects.
This takes a text string, which should be similar to normal python
import markup.
"""
self._build_map(text)
self._convert_imports(scope)
def _convert_imports(self, scope):
# Now convert the map into a set of imports
for name, info in self.imports.iteritems():
self._lazy_import_class(scope, name=name, module_path=info[0],
member=info[1], children=info[2])
def _build_map(self, text):
"""Take a string describing imports, and build up the internal map"""
for line in self._canonicalize_import_text(text):
if line.startswith('import '):
self._convert_import_str(line)
elif line.startswith('from '):
self._convert_from_str(line)
else:
raise errors.InvalidImportLine(line,
"doesn't start with 'import ' or 'from '")
def _convert_import_str(self, import_str):
"""This converts a import string into an import map.
This only understands 'import foo, foo.bar, foo.bar.baz as bing'
:param import_str: The import string to process
"""
if not import_str.startswith('import '):
raise ValueError('bad import string %r' % (import_str,))
import_str = import_str[len('import '):]
for path in import_str.split(','):
path = path.strip()
if not path:
continue
as_hunks = path.split(' as ')
if len(as_hunks) == 2:
# We have 'as' so this is a different style of import
# 'import foo.bar.baz as bing' creates a local variable
# named 'bing' which points to 'foo.bar.baz'
name = as_hunks[1].strip()
module_path = as_hunks[0].strip().split('.')
if name in self.imports:
raise errors.ImportNameCollision(name)
# No children available in 'import foo as bar'
self.imports[name] = (module_path, None, {})
else:
# Now we need to handle
module_path = path.split('.')
name = module_path[0]
if name not in self.imports:
# This is a new import that we haven't seen before
module_def = ([name], None, {})
self.imports[name] = module_def
else:
module_def = self.imports[name]
cur_path = [name]
cur = module_def[2]
for child in module_path[1:]:
cur_path.append(child)
if child in cur:
cur = cur[child][2]
else:
next = (cur_path[:], None, {})
cur[child] = next
cur = next[2]
def _convert_from_str(self, from_str):
"""This converts a 'from foo import bar' string into an import map.
:param from_str: The import string to process
"""
if not from_str.startswith('from '):
raise ValueError('bad from/import %r' % from_str)
from_str = from_str[len('from '):]
from_module, import_list = from_str.split(' import ')
from_module_path = from_module.split('.')
for path in import_list.split(','):
path = path.strip()
if not path:
continue
as_hunks = path.split(' as ')
if len(as_hunks) == 2:
# We have 'as' so this is a different style of import
# 'import foo.bar.baz as bing' creates a local variable
# named 'bing' which points to 'foo.bar.baz'
name = as_hunks[1].strip()
module = as_hunks[0].strip()
else:
name = module = path
if name in self.imports:
raise errors.ImportNameCollision(name)
self.imports[name] = (from_module_path, module, {})
def _canonicalize_import_text(self, text):
"""Take a list of imports, and split it into regularized form.
This is meant to take regular import text, and convert it to
the forms that the rest of the converters prefer.
"""
out = []
cur = None
continuing = False
for line in text.split('\n'):
line = line.strip()
loc = line.find('#')
if loc != -1:
line = line[:loc].strip()
if not line:
continue
if cur is not None:
if line.endswith(')'):
out.append(cur + ' ' + line[:-1])
cur = None
else:
cur += ' ' + line
else:
if '(' in line and ')' not in line:
cur = line.replace('(', '')
else:
out.append(line.replace('(', '').replace(')', ''))
if cur is not None:
raise errors.InvalidImportLine(cur, 'Unmatched parenthesis')
return out
def lazy_import(scope, text, lazy_import_class=None):
"""Create lazy imports for all of the imports in text.
This is typically used as something like::
from bzrlib.lazy_import import lazy_import
lazy_import(globals(), '''
from bzrlib import (
foo,
bar,
baz,
)
import bzrlib.branch
import bzrlib.transport
''')
Then 'foo, bar, baz' and 'bzrlib' will exist as lazy-loaded
objects which will be replaced with a real object on first use.
In general, it is best to only load modules in this way. This is
because other objects (functions/classes/variables) are frequently
used without accessing a member, which means we cannot tell they
have been used.
"""
# This is just a helper around ImportProcessor.lazy_import
proc = ImportProcessor(lazy_import_class=lazy_import_class)
return proc.lazy_import(scope, text)
# The only module that this module depends on is 'bzrlib.errors'. But it
# can actually be imported lazily, since we only need it if there is a
# problem.
lazy_import(globals(), """
from bzrlib import errors
""")
|