def test_module(self):
self._clearModules('spam')
imports.whenImported('spam', self._hook)
self.assertTrue('spam' in imports.postLoadHooks.keys())
self.assertEquals(imports.postLoadHooks['spam'], [self._hook])
import spam
imports._loadModule(spam)
self.assertTrue(self.executed)
def test_module(self):
self._clearModules('spam')
imports.whenImported('spam', self._hook)
self.assertTrue('spam' in imports.postLoadHooks.keys())
self.assertEquals(imports.postLoadHooks['spam'], [self._hook])
import spam
imports._loadModule(spam)
self.assertTrue(self.executed)
def test_multipleChildDeepParent(self):
self._clearModules('foo', 'foo.bar', 'foo.bar.baz', 'foo.bar.gak')
self._mods = []
imports.whenImported('foo.bar.baz', lambda m: self._mods.append(m))
imports.whenImported('foo.bar.gak', lambda m: self._mods.append(m))
import foo.bar.baz
import foo.bar.gak
imports._loadModule(foo.bar.baz)
imports._loadModule(foo.bar.gak)
self.assertEquals(self._mods, [foo.bar.baz, foo.bar.gak])
def test_submodule(self):
self._clearModules("foo", "foo.bar", "foo.bar.baz")
imports.whenImported("foo.bar.baz", self._hook)
self.assertTrue("foo" in imports.postLoadHooks.keys())
self.assertFalse("foo.bar" in imports.postLoadHooks.keys())
self.assertFalse("foo.bar.baz" in imports.postLoadHooks.keys())
self.assertEquals(len(imports.postLoadHooks["foo"]), 1)
import foo
imports._loadModule(foo)
self.assertTrue("foo" in imports.postLoadHooks.keys())
self.assertTrue("foo.bar" in imports.postLoadHooks.keys())
self.assertFalse("foo.bar.baz" in imports.postLoadHooks.keys())
self.assertEquals(imports.postLoadHooks["foo"], None)
self.assertEquals(len(imports.postLoadHooks["foo.bar"]), 1)
self.assertTrue(hasattr(foo, "bar"))
self.assertEquals(self.executed, False)
# ensure that the module was actually loaded
self.assertEquals(foo.spam, "eggs")
import foo.bar
imports._loadModule(foo.bar)
self.assertTrue("foo" in imports.postLoadHooks.keys())
self.assertTrue("foo.bar" in imports.postLoadHooks.keys())
self.assertTrue("foo.bar.baz" in imports.postLoadHooks.keys())
self.assertEquals(imports.postLoadHooks["foo"], None)
self.assertEquals(imports.postLoadHooks["foo.bar"], None)
self.assertEquals(len(imports.postLoadHooks["foo.bar.baz"]), 1)
self.assertTrue(hasattr(foo.bar, "baz"))
self.assertEquals(self.executed, False)
import foo.bar.baz
imports._loadModule(foo.bar.baz)
self.assertTrue("foo" in imports.postLoadHooks.keys())
self.assertTrue("foo.bar" in imports.postLoadHooks.keys())
self.assertTrue("foo.bar.baz" in imports.postLoadHooks.keys())
self.assertEquals(imports.postLoadHooks["foo"], None)
self.assertEquals(imports.postLoadHooks["foo.bar"], None)
self.assertEquals(imports.postLoadHooks["foo.bar.baz"], None)
self.assertEquals(self.executed, True)
def register_adapters():
global adapters_registered
if adapters_registered is True:
return
try:
import pkg_resources
packageDir = pkg_resources.resource_filename('pyamf', 'adapters')
except:
packageDir = os.path.dirname(__file__)
for f in glob.glob(os.path.join(packageDir, '*.py')):
mod = os.path.basename(f).split(os.path.extsep, 1)[0]
if mod == '__init__' or not mod.startswith('_'):
continue
try:
module = imports.whenImported(mod[1:].replace('_', '.'),
PackageImporter(mod))
except ImportError:
pass
adapters_registered = True
def test_submodule(self):
self._clearModules('foo', 'foo.bar', 'foo.bar.baz')
imports.whenImported('foo.bar.baz', self._hook)
self.assertTrue('foo' in imports.postLoadHooks.keys())
self.assertFalse('foo.bar' in imports.postLoadHooks.keys())
self.assertFalse('foo.bar.baz' in imports.postLoadHooks.keys())
self.assertEquals(len(imports.postLoadHooks['foo']), 1)
import foo
imports._loadModule(foo)
self.assertTrue('foo' in imports.postLoadHooks.keys())
self.assertTrue('foo.bar' in imports.postLoadHooks.keys())
self.assertFalse('foo.bar.baz' in imports.postLoadHooks.keys())
self.assertEquals(imports.postLoadHooks['foo'], None)
self.assertEquals(len(imports.postLoadHooks['foo.bar']), 1)
self.assertTrue(hasattr(foo, 'bar'))
self.assertEquals(self.executed, False)
# ensure that the module was actually loaded
self.assertEquals(foo.spam, 'eggs')
import foo.bar
imports._loadModule(foo.bar)
self.assertTrue('foo' in imports.postLoadHooks.keys())
self.assertTrue('foo.bar' in imports.postLoadHooks.keys())
self.assertTrue('foo.bar.baz' in imports.postLoadHooks.keys())
self.assertEquals(imports.postLoadHooks['foo'], None)
self.assertEquals(imports.postLoadHooks['foo.bar'], None)
self.assertEquals(len(imports.postLoadHooks['foo.bar.baz']), 1)
self.assertTrue(hasattr(foo.bar, 'baz'))
self.assertEquals(self.executed, False)
import foo.bar.baz
imports._loadModule(foo.bar.baz)
self.assertTrue('foo' in imports.postLoadHooks.keys())
self.assertTrue('foo.bar' in imports.postLoadHooks.keys())
self.assertTrue('foo.bar.baz' in imports.postLoadHooks.keys())
self.assertEquals(imports.postLoadHooks['foo'], None)
self.assertEquals(imports.postLoadHooks['foo.bar'], None)
self.assertEquals(imports.postLoadHooks['foo.bar.baz'], None)
self.assertEquals(self.executed, True)
def test_submodule(self):
self._clearModules('foo', 'foo.bar', 'foo.bar.baz')
imports.whenImported('foo.bar.baz', self._hook)
self.assertTrue('foo' in imports.postLoadHooks.keys())
self.assertFalse('foo.bar' in imports.postLoadHooks.keys())
self.assertFalse('foo.bar.baz' in imports.postLoadHooks.keys())
self.assertEquals(len(imports.postLoadHooks['foo']), 1)
import foo
imports._loadModule(foo)
self.assertTrue('foo' in imports.postLoadHooks.keys())
self.assertTrue('foo.bar' in imports.postLoadHooks.keys())
self.assertFalse('foo.bar.baz' in imports.postLoadHooks.keys())
self.assertEquals(imports.postLoadHooks['foo'], None)
self.assertEquals(len(imports.postLoadHooks['foo.bar']), 1)
self.assertTrue(hasattr(foo, 'bar'))
self.assertEquals(self.executed, False)
# ensure that the module was actually loaded
self.assertEquals(foo.spam, 'eggs')
import foo.bar
imports._loadModule(foo.bar)
self.assertTrue('foo' in imports.postLoadHooks.keys())
self.assertTrue('foo.bar' in imports.postLoadHooks.keys())
self.assertTrue('foo.bar.baz' in imports.postLoadHooks.keys())
self.assertEquals(imports.postLoadHooks['foo'], None)
self.assertEquals(imports.postLoadHooks['foo.bar'], None)
self.assertEquals(len(imports.postLoadHooks['foo.bar.baz']), 1)
self.assertTrue(hasattr(foo.bar, 'baz'))
self.assertEquals(self.executed, False)
import foo.bar.baz
imports._loadModule(foo.bar.baz)
self.assertTrue('foo' in imports.postLoadHooks.keys())
self.assertTrue('foo.bar' in imports.postLoadHooks.keys())
self.assertTrue('foo.bar.baz' in imports.postLoadHooks.keys())
self.assertEquals(imports.postLoadHooks['foo'], None)
self.assertEquals(imports.postLoadHooks['foo.bar'], None)
self.assertEquals(imports.postLoadHooks['foo.bar.baz'], None)
self.assertEquals(self.executed, True)
def register_adapter(mod, func):
"""
Registers a callable to be executed when a module is imported. If the
module already exists then the callable will be executed immediately.
You can register the same module multiple times, the callables will be
executed in the order they were registered. The root module must exist
(i.e. be importable) otherwise an C{ImportError} will be thrown
@param mod: The fully qualified module string, as used in the imports
statement. E.g. 'foo.bar.baz'. The string must map to a module
otherwise the callable will not fire.
@type mod: C{str}
@param func: The function to call when C{mod} is imported. This function
must take one arg, the newly imported C{module} object.
@type func: callable
"""
if not callable(func):
raise TypeError('func must be callable')
imports.whenImported(str(mod), func)
def register_adapter(mod, func):
"""
Registers a callable to be executed when a module is imported. If the
module already exists then the callable will be executed immediately.
You can register the same module multiple times, the callables will be
executed in the order they were registered. The root module must exist
(i.e. be importable) otherwise an C{ImportError} will be thrown
@param mod: The fully qualified module string, as used in the imports
statement. E.g. 'foo.bar.baz'. The string must map to a module
otherwise the callable will not fire.
@type mod: C{str}
@param func: The function to call when C{mod} is imported. This function
must take one arg, the newly imported C{module} object.
@type func: callable
"""
if not callable(func):
raise TypeError('func must be callable')
imports.whenImported(str(mod), func)
def register_adapters():
global adapters_registered
if adapters_registered is True:
return
try:
import pkg_resources
packageDir = pkg_resources.resource_filename('pyamf', 'adapters')
except:
packageDir = os.path.dirname(__file__)
for f in glob.glob(os.path.join(packageDir, '*.py')):
mod = os.path.basename(f).split(os.path.extsep, 1)[0]
if mod == '__init__' or not mod.startswith('_'):
continue
try:
module = imports.whenImported(mod[1:].replace('_', '.'), PackageImporter(mod))
except ImportError:
pass
adapters_registered = True
try:
referenced_object = gae_objects.getClassKey(kls, s)
except KeyError:
gae_objects.addClassKey(kls, s, object)
self.writeNonGAEObject(object, *args, **kwargs)
return
self.writeNonGAEObject(referenced_object, *args, **kwargs)
def install_gae_reference_model_hook(mod):
"""
Called when L{pyamf.amf0} or L{pyamf.amf3} are imported. Attaches the
L{writeGAEObject} method to the C{Encoder} class in that module.
@param mod: The module imported.
@since: 0.4.1
"""
if not hasattr(mod.Encoder, 'writeNonGAEObject'):
mod.Encoder.writeNonGAEObject = mod.Encoder.writeObject
mod.Encoder.writeObject = writeGAEObject
# initialise the module here: hook into pyamf
pyamf.add_type(db.Query, util.to_list)
pyamf.register_alias_type(DataStoreClassAlias, db.Model, db.Expando)
# hook the L{writeGAEObject} method to the Encoder class on import
imports.whenImported('pyamf.amf0', install_gae_reference_model_hook)
imports.whenImported('pyamf.amf3', install_gae_reference_model_hook)
try:
referenced_object = gae_objects.getClassKey(kls, s)
except KeyError:
gae_objects.addClassKey(kls, s, object)
self.writeNonGAEObject(object, *args, **kwargs)
return
self.writeNonGAEObject(referenced_object, *args, **kwargs)
def install_gae_reference_model_hook(mod):
"""
Called when L{pyamf.amf0} or L{pyamf.amf3} are imported. Attaches the
L{writeGAEObject} method to the C{Encoder} class in that module.
@param mod: The module imported.
@since: 0.4.1
"""
if not hasattr(mod.Encoder, 'writeNonGAEObject'):
mod.Encoder.writeNonGAEObject = mod.Encoder.writeObject
mod.Encoder.writeObject = writeGAEObject
# initialise the module here: hook into pyamf
pyamf.add_type(db.Query, util.to_list)
pyamf.register_alias_type(DataStoreClassAlias, db.Model, db.Expando)
# hook the L{writeGAEObject} method to the Encoder class on import
imports.whenImported('pyamf.amf0', install_gae_reference_model_hook)
imports.whenImported('pyamf.amf3', install_gae_reference_model_hook)
