def check_etree(self):
# holy hack batman
import inspect
mod = inspect.stack()[1][0].f_locals['testMethod'].__name__[5:]
mod = mod.replace('_', '.')
try:
etree = util.get_module(mod)
except ImportError:
self.skipTest('%r is not available' % (mod, ))
element = etree.fromstring(self.xml)
xml = etree.tostring(element)
old = pyamf.set_default_etree(etree)
if old:
self.addCleanup(lambda x: pyamf.set_default_etree(x), old)
bytes = pyamf.encode(element, encoding=pyamf.AMF0).getvalue()
self.check_amf0(bytes, xml)
new_element = pyamf.decode(bytes, encoding=pyamf.AMF0).next()
self.assertIdentical(type(element), type(new_element))
bytes = pyamf.encode(element, encoding=pyamf.AMF3).getvalue()
self.check_amf3(bytes, xml)
new_element = pyamf.decode(bytes, encoding=pyamf.AMF3).next()
self.assertIdentical(type(element), type(new_element))
def find_libs():
"""
Run through L{ETREE_MODULES} and find C{ElementTree} implementations so
that any type can be encoded.
We work through the C implementations first, then the pure Python versions.
The downside to this is that B{all} libraries will be imported but I{only}
one is ever used. The libs are small (relatively) and the flexibility that
this gives seems to outweigh the cost. Time will tell.
"""
from pyamf.util import get_module
types = []
mapping = {}
for mod in ETREE_MODULES:
try:
etree = get_module(mod)
except ImportError:
continue
try:
t = _get_etree_type(etree)
except TypeError:
continue
types.append(t)
mapping[t] = etree
return tuple(types), mapping
def find_libs():
"""
Run through L{ETREE_MODULES} and find C{ElementTree} implementations so
that any type can be encoded.
We work through the C implementations first, then the pure Python versions.
The downside to this is that B{all} libraries will be imported but I{only}
one is ever used. The libs are small (relatively) and the flexibility that
this gives seems to outweigh the cost. Time will tell.
"""
from pyamf.util import get_module
types = []
mapping = {}
for mod in ETREE_MODULES:
try:
etree = get_module(mod)
except ImportError:
continue
try:
t = _get_etree_type(etree)
except TypeError:
continue
types.append(t)
mapping[t] = etree
return tuple(types), mapping
def check_etree(self):
# holy hack batman
import inspect
mod = inspect.stack()[1][0].f_locals['testMethod'].__name__[5:]
mod = mod.replace('_', '.')
try:
etree = util.get_module(mod)
except ImportError:
self.skipTest('%r is not available' % (mod,))
element = etree.fromstring(self.xml)
xml = etree.tostring(element)
old = pyamf.set_default_etree(etree)
if old:
self.addCleanup(lambda x: pyamf.set_default_etree(x), old)
bytes = pyamf.encode(element, encoding=pyamf.AMF0).getvalue()
self.check_amf0(bytes, xml)
new_element = pyamf.decode(bytes, encoding=pyamf.AMF0).next()
self.assertIdentical(type(element), type(new_element))
bytes = pyamf.encode(element, encoding=pyamf.AMF3).getvalue()
self.check_amf3(bytes, xml)
new_element = pyamf.decode(bytes, encoding=pyamf.AMF3).next()
self.assertIdentical(type(element), type(new_element))
def setUp(self):
try:
self.etree = util.get_module(self.mod)
except ImportError:
self.skipTest('%r is not available' % (self.mod,))
previous_etree = pyamf.set_default_etree(self.etree)
if previous_etree:
self.addCleanup(lambda: pyamf.set_default_etree(previous_etree))
def setUp(self):
try:
self.etree = util.get_module(self.mod)
except ImportError:
self.skipTest('%r is not available' % (self.mod, ))
previous_etree = pyamf.set_default_etree(self.etree)
if previous_etree:
self.addCleanup(lambda: pyamf.set_default_etree(previous_etree))
def load_class(alias):
"""
Finds the class registered to the alias.
The search is done in order:
1. Checks if the class name has been registered via L{register_class}
or L{register_package}.
2. Checks all functions registered via L{register_class_loader}.
3. Attempts to load the class via standard module loading techniques.
@param alias: The class name.
@type alias: C{string}
@raise UnknownClassAlias: The C{alias} was not found.
@raise TypeError: Expecting class type or L{ClassAlias} from loader.
@return: Class registered to the alias.
@rtype: C{classobj}
"""
# Try the CLASS_CACHE first
try:
return CLASS_CACHE[alias]
except KeyError:
pass
for loader in CLASS_LOADERS:
klass = loader(alias)
if klass is None:
continue
if isinstance(klass, python.class_types):
return register_class(klass, alias)
elif isinstance(klass, ClassAlias):
CLASS_CACHE[klass.alias] = klass
CLASS_CACHE[klass.klass] = klass
return klass
raise TypeError("Expecting class object or ClassAlias from loader")
mod_class = alias.split(".")
if mod_class:
module = ".".join(mod_class[:-1])
klass = mod_class[-1]
try:
module = util.get_module(module)
except (ImportError, AttributeError):
pass
else:
klass = getattr(module, klass)
if isinstance(klass, python.class_types):
return register_class(klass, alias)
elif isinstance(klass, ClassAlias):
CLASS_CACHE[klass.alias] = klass
CLASS_CACHE[klass.klass] = klass
return klass.klass
else:
raise TypeError("Expecting class type or ClassAlias from loader")
# All available methods for finding the class have been exhausted
raise UnknownClassAlias("Unknown alias for %r" % (alias,))
def load_class(alias):
"""
Finds the class registered to the alias.
The search is done in order:
1. Checks if the class name has been registered via L{register_class}
or L{register_package}.
2. Checks all functions registered via L{register_class_loader}.
3. Attempts to load the class via standard module loading techniques.
@param alias: The class name.
@type alias: C{string}
@raise UnknownClassAlias: The C{alias} was not found.
@raise TypeError: Expecting class type or L{ClassAlias} from loader.
@return: Class registered to the alias.
@rtype: C{classobj}
"""
# Try the CLASS_CACHE first
try:
return CLASS_CACHE[alias]
except KeyError:
pass
for loader in CLASS_LOADERS:
klass = loader(alias)
if klass is None:
continue
if isinstance(klass, python.class_types):
return register_class(klass, alias)
elif isinstance(klass, ClassAlias):
CLASS_CACHE[klass.alias] = klass
CLASS_CACHE[klass.klass] = klass
return klass
raise TypeError("Expecting class object or ClassAlias from loader")
mod_class = alias.split('.')
if mod_class:
module = '.'.join(mod_class[:-1])
klass = mod_class[-1]
try:
module = util.get_module(module)
except (ImportError, AttributeError):
pass
else:
klass = getattr(module, klass)
if isinstance(klass, python.class_types):
return register_class(klass, alias)
elif isinstance(klass, ClassAlias):
CLASS_CACHE[klass.alias] = klass
CLASS_CACHE[klass.klass] = klass
return klass.klass
else:
raise TypeError(
"Expecting class type or ClassAlias from loader")
# All available methods for finding the class have been exhausted
raise UnknownClassAlias("Unknown alias for %r" % (alias, ))