def update(self, dict=None, **kwargs):
if dict:
UserDict.update(self, dict)
for key in dict:
self._add_key(key)
if kwargs:
self.update(kwargs)
def update(self, dict):
"""Updates dictionary with new items"""
with self.__rlock:
UserDict.update(self, dict)
for key in dict.keys():
if key not in self._keys:
self._keys.append(key)
def update(self, dict=None, **kwargs):
if dict:
UserDict.update(self, dict)
for key in dict:
self._add_key(key)
if kwargs:
self.update(kwargs)
def __init__(self, keyvalues=(), **other):
_base.__init__(self)
try: keyvalues = keyvalues.items()
except AttributeError: pass
for k,v in keyvalues:
_base.__setitem__(self,k,v)
_base.update(self,other)
self._hash = hash(tuple(self.items()))
def __init__(self, keyvalues=(), **other):
_base.__init__(self)
try:
keyvalues = keyvalues.items()
except AttributeError:
pass
for k, v in keyvalues:
_base.__setitem__(self, k, v)
_base.update(self, other)
self._hash = hash(tuple(self.items()))
def update(self, live=False):
self.data = {}
# csv update
keys = ('latitude','longitude','city','state','zipcode')
for row in rows():
if self.station == row[0]:
UserDict.update(self, dict(zip(keys,row[2:-1])))
break
if not self.data:
raise AttributeError,'Station %s not found'%self.station
# sgmllib update
self.reset()
if os.path.isfile(ZFILE) and not live:
zfile = zipfile.ZipFile(ZFILE,'r')
for name in zfile.namelist():
if name.endswith('%s.xml'%self.station):
SGMLParser.feed(self, zfile.read(name))
del zfile
break
else:
#Fetch().start()
SGMLParser.feed(self, urlopen(WURL%self.station).read())
self.close()
def update(self, live=False):
self.data = {}
# csv update
keys = ('latitude', 'longitude', 'city', 'state', 'zipcode')
for row in rows():
if self.station == row[0]:
UserDict.update(self, dict(zip(keys, row[2:-1])))
break
if not self.data:
raise AttributeError, 'Station %s not found' % self.station
# sgmllib update
self.reset()
if os.path.isfile(ZFILE) and not live:
zfile = zipfile.ZipFile(ZFILE, 'r')
for name in zfile.namelist():
if name.endswith('%s.xml' % self.station):
SGMLParser.feed(self, zfile.read(name))
del zfile
break
else:
#Fetch().start()
SGMLParser.feed(self, urlopen(WURL % self.station).read())
self.close()
class Transform(SimpleItem):
"""A transform is an external method with
additional configuration information
"""
implements(ITransform)
meta_type = "Transform"
meta_types = all_meta_types = ()
manage_options = (
{"label": "Configure", "action": "manage_main"},
{"label": "Reload", "action": "manage_reloadTransform"},
) + SimpleItem.manage_options
manage_main = PageTemplateFile("configureTransform", _www)
manage_reloadTransform = PageTemplateFile("reloadTransform", _www)
tr_widgets = PageTemplateFile("tr_widgets", _www)
security = ClassSecurityInfo()
__allow_access_to_unprotected_subobjects__ = 1
def __init__(self, id, module, transform=None):
self.id = id
self.module = module
# DM 2004-09-09: 'Transform' instances are stored as
# part of a module level configuration structure
# Therefore, they must not contain persistent objects
self._config = UserDict()
self._config.__allow_access_to_unprotected_subobjects__ = 1
self._config_metadata = UserDict()
self._tr_init(1, transform)
def __setstate__(self, state):
""" __setstate__ is called whenever the instance is loaded
from the ZODB, like when Zope is restarted.
We should reload the wrapped transform at this time
"""
Transform.inheritedAttribute("__setstate__")(self, state)
self._tr_init()
def _tr_init(self, set_conf=0, transform=None):
""" initialize the zope transform by loading the wrapped transform """
__traceback_info__ = (self.module,)
if transform is None:
transform = self._load_transform()
else:
self._v_transform = transform
# check this is a valid transform
if not hasattr(transform, "__class__"):
raise TransformException("Invalid transform : transform is not a class")
if not ITransform.providedBy(transform):
raise TransformException("Invalid transform : ITransform is not implemented by %s" % transform.__class__)
if not hasattr(transform, "inputs"):
raise TransformException('Invalid transform : missing required "inputs" attribute')
if not hasattr(transform, "output"):
raise TransformException('Invalid transform : missing required "output" attribute')
# manage configuration
if set_conf and hasattr(transform, "config"):
conf = dict(transform.config)
self._config.update(conf)
make_config_persistent(self._config)
if hasattr(transform, "config_metadata"):
conf = dict(transform.config_metadata)
self._config_metadata.update(conf)
make_config_persistent(self._config_metadata)
transform.config = dict(self._config)
make_config_nonpersistent(transform.config)
transform.config_metadata = dict(self._config_metadata)
make_config_nonpersistent(transform.config_metadata)
self.inputs = transform.inputs
self.output = transform.output
self.output_encoding = getattr(transform, "output_encoding", None)
return transform
def _load_transform(self):
try:
m = import_from_name(self.module)
except ImportError, err:
transform = BrokenTransform(self.id, self.module, err)
msg = "Cannot register transform %s (ImportError), using BrokenTransform: Error\n %s" % (self.id, err)
self.title = "BROKEN"
log(msg, severity=ERROR)
return transform
if not hasattr(m, "register"):
msg = "Invalid transform module %s: no register function defined" % self.module
raise TransformException(msg)
try:
transform = m.register()
except Exception, err:
transform = BrokenTransform(self.id, self.module, err)
msg = "Cannot register transform %s, using BrokenTransform: Error\n %s" % (self.id, err)
self.title = "BROKEN"
log(msg, severity=ERROR)
def update(self, dict):
for k in dict.keys():
if not self.data.has_key(k):
self._keys.append(k)
return BaseDict.update(self, dict)
def update(self, dict):
for k in dict.keys():
if k not in self.data:
self._keys.append(k)
return BaseDict.update(self, dict)
def update(self, dict):
self.__populate()
UserDict.update( self, dict )
class Transform(SimpleItem):
"""A transform is an external method with
additional configuration information
"""
implements(ITransform)
meta_type = 'Transform'
meta_types = all_meta_types = ()
manage_options = ((
{
'label': 'Configure',
'action': 'manage_main'
},
{
'label': 'Reload',
'action': 'manage_reloadTransform'
},
) + SimpleItem.manage_options)
manage_main = PageTemplateFile('configureTransform', _www)
manage_reloadTransform = PageTemplateFile('reloadTransform', _www)
tr_widgets = PageTemplateFile('tr_widgets', _www)
security = ClassSecurityInfo()
__allow_access_to_unprotected_subobjects__ = 1
def __init__(self, id, module, transform=None):
self.id = id
self.module = module
# DM 2004-09-09: 'Transform' instances are stored as
# part of a module level configuration structure
# Therefore, they must not contain persistent objects
self._config = UserDict()
self._config.__allow_access_to_unprotected_subobjects__ = 1
self._config_metadata = UserDict()
self._tr_init(1, transform)
def __setstate__(self, state):
""" __setstate__ is called whenever the instance is loaded
from the ZODB, like when Zope is restarted.
We should reload the wrapped transform at this time
"""
Transform.inheritedAttribute('__setstate__')(self, state)
self._tr_init()
def _tr_init(self, set_conf=0, transform=None):
""" initialize the zope transform by loading the wrapped transform """
__traceback_info__ = (self.module, )
if transform is None:
transform = self._load_transform()
else:
self._v_transform = transform
# check this is a valid transform
if not hasattr(transform, '__class__'):
raise TransformException(
'Invalid transform : transform is not a class')
if not ITransform.providedBy(transform):
raise TransformException(
'Invalid transform : ITransform is not implemented by %s' %
transform.__class__)
if not hasattr(transform, 'inputs'):
raise TransformException(
'Invalid transform : missing required "inputs" attribute')
if not hasattr(transform, 'output'):
raise TransformException(
'Invalid transform : missing required "output" attribute')
# manage configuration
if set_conf and hasattr(transform, 'config'):
conf = dict(transform.config)
self._config.update(conf)
make_config_persistent(self._config)
if hasattr(transform, 'config_metadata'):
conf = dict(transform.config_metadata)
self._config_metadata.update(conf)
make_config_persistent(self._config_metadata)
transform.config = dict(self._config)
make_config_nonpersistent(transform.config)
transform.config_metadata = dict(self._config_metadata)
make_config_nonpersistent(transform.config_metadata)
self.inputs = transform.inputs
self.output = transform.output
self.output_encoding = getattr(transform, 'output_encoding', None)
return transform
def _load_transform(self):
try:
m = import_from_name(self.module)
except ImportError, err:
transform = BrokenTransform(self.id, self.module, err)
msg = ("Cannot register transform %s (ImportError), using "
"BrokenTransform: Error\n %s" % (self.id, err))
self.title = 'BROKEN'
log(msg, severity=ERROR)
return transform
if not hasattr(m, 'register'):
msg = ("Invalid transform module %s: no register function "
"defined" % self.module)
raise TransformException(msg)
try:
transform = m.register()
except Exception, err:
transform = BrokenTransform(self.id, self.module, err)
msg = ("Cannot register transform %s, using BrokenTransform: "
"Error\n %s" % (self.id, err))
self.title = 'BROKEN'
log(msg, severity=ERROR)
m2 = MyUserDict(u2)
m2a = m2.copy()
assert m2a == m2
# Test keys, items, values
assert u2.keys() == d2.keys()
assert u2.items() == d2.items()
assert u2.values() == d2.values()
# Test has_key
for i in u2.keys():
assert u2.has_key(i) == 1
assert u1.has_key(i) == d1.has_key(i)
assert u0.has_key(i) == d0.has_key(i)
# Test update
t = UserDict()
t.update(u2)
assert t == u2
# Test get
for i in u2.keys():
assert u2.get(i) == u2[i]
assert u1.get(i) == d1.get(i)
assert u0.get(i) == d0.get(i)
# Check every path through every method of UserDict
from test_support import verify, verbose
from UserDict import UserDict, IterableUserDict
d0 = {}
d1 = {"one": 1}
d2 = {"one": 1, "two": 2}
# Test constructors
u = UserDict()
u0 = UserDict(d0)
u1 = UserDict(d1)
u2 = IterableUserDict(d2)
uu = UserDict(u)
uu0 = UserDict(u0)
uu1 = UserDict(u1)
uu2 = UserDict(u2)
# Test __repr__
verify(str(u0) == str(d0))
verify(repr(u1) == repr(d1))
verify( ` u2 ` == ` d2 `)
# Test __cmp__ and __len__
all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
for a in all:
for b in all:
verify(cmp(a, b) == cmp(len(a), len(b)))
# Test __getitem__
verify(u2["one"] == 1)
try:
u1["two"]
except KeyError:
pass
def update(self, d):
_dict.update(self, d)
self._dirty=1
def update(self, dict):
UserDict.update(self, dict)
for key in dict:
if key not in self._keys: self._keys.append(key)
class Predictor(SimpleItem):
"""A predictor is an external method with
additional configuration information
"""
implements(IPredictor)
meta_type = "Predictor"
meta_types = all_meta_types = ()
def __init__(self, id, module, predictor=None):
self.id = id
self.module = module
self._class = predictor.__class__.__name__
# DM 2004-09-09: 'Transform' instances are stored as
# part of a module level configuration structure
# Therefore, they must not contain persistent objects
self._config = UserDict()
self._config.__allow_access_to_unprotected_subobjects__ = 1
self._config_metadata = UserDict()
self._predictor_init(1, predictor)
def predictorclass(self):
""" """
return self.module + "." + self._class
def name(self):
"""return the name of the predictor instance"""
return self.id
def _predictor_init(self, set_conf=0, predictor=None):
""" """
__traceback_info__ = (self.module,)
if predictor is None:
predictor = self._load_predictor()
else:
self._v_predictor = predictor
# check this is a valid predictor
if not hasattr(predictor, "__class__"):
raise Plone4BioException("Invalid predictor : predictor is not a class")
if not IPredictor.providedBy(predictor):
raise Plone4BioException("Invalid predictor : IPredictor is not implemented by %s" % predictor.__class__)
# if not hasattr(predictor, 'run'):
# raise Plone4BioException('Invalid predictor : missing required "run" attribute')
# manage configuration
if set_conf and hasattr(predictor, "config"):
conf = dict(predictor.config)
self._config.update(conf)
make_config_persistent(self._config)
if hasattr(predictor, "config_metadata"):
conf = dict(predictor.config_metadata)
self._config_metadata.update(conf)
make_config_persistent(self._config_metadata)
predictor.config = dict(self._config)
make_config_nonpersistent(predictor.config)
predictor.config_metadata = dict(self._config_metadata)
make_config_nonpersistent(predictor.config_metadata)
# self.inputs = predictor.inputs
# self.output = predictor.output
# self.output_encoding = getattr(predictor, 'output_encoding', None)
return predictor
def _load_predictor(self):
klass = self.predictorclass()
__traceback_info__ = klass
parts = klass.split(".")
if not parts:
raise ValueError, "incomplete klass name: %s" % klass
parts_copy = parts[:]
while parts_copy:
try:
module = __import__(".".join(parts_copy))
break
except ImportError:
# Reraise if the import error was caused inside the imported file
if sys.exc_info()[2].tb_next is not None:
raise
del parts_copy[-1]
if not parts_copy:
return None
parts = parts[1:] # Funky semantics of __import__'s return value
obj = module
for part in parts:
try:
obj = getattr(obj, part)
except AttributeError:
return None
self._v_predictor = obj()
def run(self, obj, context=None, store=False, argv=([], {})):
""" """
assert type(argv[0]) == list
assert type(argv[1]) == dict
if not hasattr(self, "_v_predictor"):
self._load_predictor()
if ISeqRecord.providedBy(obj):
newseqr = self._v_predictor.run(obj.getSeqRecord(), *argv[0], **argv[1])
if store:
# TODO: need locking?
obj.features = newseqr.features
# TODO: raise event
return obj
else:
return SeqRecord(newseqr.id, title=newseqr.name, seqrecord=newseqr)
else:
newseqr = self._v_predictor.run(obj, *argv[0], **argv[1])
if store:
obj.features = newseqr.features
return obj
else:
return newseqr
# Check every path through every method of UserDict
from test_support import verify, verbose
from UserDict import UserDict, IterableUserDict
d0 = {}
d1 = {"one": 1}
d2 = {"one": 1, "two": 2}
# Test constructors
u = UserDict()
u0 = UserDict(d0)
u1 = UserDict(d1)
u2 = IterableUserDict(d2)
uu = UserDict(u)
uu0 = UserDict(u0)
uu1 = UserDict(u1)
uu2 = UserDict(u2)
# Test __repr__
verify(str(u0) == str(d0))
verify(repr(u1) == repr(d1))
verify(`u2` == `d2`)
# Test __cmp__ and __len__
all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
for a in all:
for b in all:
verify(cmp(a, b) == cmp(len(a), len(b)))
# Test __getitem__
verify(u2["one"] == 1)
try:
u1["two"]
except KeyError:
pass
class Transform(SimpleItem):
"""A transform is an external method with
additional configuration information
"""
meta_type = 'Transform'
meta_types = all_meta_types = ()
manage_options = ((
{
'label': 'Configure',
'action': 'manage_main'
},
{
'label': 'Reload',
'action': 'manage_reloadTransform'
},
) + SimpleItem.manage_options)
manage_main = PageTemplateFile('configureTransform', _www)
manage_reloadTransform = PageTemplateFile('reloadTransform', _www)
tr_widgets = PageTemplateFile('tr_widgets', _www)
security = ClassSecurityInfo()
__allow_access_to_unprotected_subobjects__ = 1
def __init__(self, id, module, transform=None):
self.id = id
self.module = module
# DM 2004-09-09: 'Transform' instances are stored as
# part of a module level configuration structure
# Therefore, they must not contain persistent objects
self._config = UserDict()
self._config.__allow_access_to_unprotected_subobjects__ = 1
self._config_metadata = UserDict()
self._tr_init(1, transform)
def __setstate__(self, state):
""" __setstate__ is called whenever the instance is loaded
from the ZODB, like when Zope is restarted.
We should reload the wrapped transform at this time
"""
Transform.inheritedAttribute('__setstate__')(self, state)
self._tr_init()
def _tr_init(self, set_conf=0, transform=None):
""" initialize the zope transform by loading the wrapped transform """
__traceback_info__ = (self.module, )
if transform is None:
transform = self._load_transform()
else:
self._v_transform = transform
# check this is a valid transform
if not hasattr(transform, '__class__'):
raise TransformException(
'Invalid transform : transform is not a class')
if not ITransform.providedBy(transform):
raise TransformException(
'Invalid transform : ITransform is not implemented by %s' %
transform.__class__)
if not hasattr(transform, 'inputs'):
raise TransformException(
'Invalid transform : missing required "inputs" attribute')
if not hasattr(transform, 'output'):
raise TransformException(
'Invalid transform : missing required "output" attribute')
# manage configuration
if set_conf and hasattr(transform, 'config'):
conf = dict(transform.config)
self._config.update(conf)
make_config_persistent(self._config)
if hasattr(transform, 'config_metadata'):
conf = dict(transform.config_metadata)
self._config_metadata.update(conf)
make_config_persistent(self._config_metadata)
transform.config = dict(self._config)
make_config_nonpersistent(transform.config)
transform.config_metadata = dict(self._config_metadata)
make_config_nonpersistent(transform.config_metadata)
self.inputs = transform.inputs
self.output = transform.output
self.output_encoding = getattr(transform, 'output_encoding', None)
return transform
def _load_transform(self):
try:
m = import_from_name(self.module)
except ImportError as err:
transform = BrokenTransform(self.id, self.module, err)
msg = ("Cannot register transform %s (ImportError), using "
"BrokenTransform: Error\n %s" % (self.id, err))
self.title = 'BROKEN'
log(msg, severity=ERROR)
return transform
if not hasattr(m, 'register'):
msg = ("Invalid transform module %s: no register function "
"defined" % self.module)
raise TransformException(msg)
try:
transform = m.register()
except Exception as err:
transform = BrokenTransform(self.id, self.module, err)
msg = ("Cannot register transform %s, using BrokenTransform: "
"Error\n %s" % (self.id, err))
self.title = 'BROKEN'
log(msg, severity=ERROR)
else:
self.title = ''
self._v_transform = transform
return transform
@security.private
def manage_beforeDelete(self, item, container):
SimpleItem.manage_beforeDelete(self, item, container)
if self is item:
# unregister self from catalog on deletion
tr_tool = getToolByName(self, 'portal_transforms')
tr_tool._unmapTransform(self)
@security.public
def get_documentation(self):
""" return transform documentation """
if not hasattr(self, '_v_transform'):
self._load_transform()
return self._v_transform.__doc__
@security.public
def convert(self, *args, **kwargs):
# return apply the transform and return the result
if not hasattr(self, '_v_transform'):
self._load_transform()
return self._v_transform.convert(*args, **kwargs)
@security.public
def name(self):
"""return the name of the transform instance"""
return self.id
@security.protected(ManagePortal)
def get_parameters(self):
""" get transform's parameters names """
if not hasattr(self, '_v_transform'):
self._load_transform()
keys = sorted(self._v_transform.config.keys())
return keys
@security.protected(ManagePortal)
def get_parameter_value(self, key):
""" get value of a transform's parameter """
value = self._config[key]
type = self.get_parameter_infos(key)[0]
if type == 'dict':
result = {}
if value:
for key, val in value.items():
result[key] = val
elif type == 'list':
result = list(value)
else:
result = value
return result
@security.protected(ManagePortal)
def get_parameter_infos(self, key):
""" get informations about a parameter
return a tuple (type, label, description [, type specific data])
where type in (string, int, list, dict)
label and description are two string describing the field
there may be some additional elements specific to the type :
(key label, value label) for the dict type
"""
try:
return tuple(self._config_metadata[key])
except KeyError:
return 'string', '', ''
@security.protected(ManagePortal)
def set_parameters(self, REQUEST=None, **kwargs):
""" set transform's parameters """
if not kwargs:
kwargs = REQUEST.form
self.preprocess_param(kwargs)
for param, value in kwargs.items():
try:
self.get_parameter_value(param)
except KeyError:
log('Warning: ignored parameter %r' % param)
continue
meta = self.get_parameter_infos(param)
self._config[param] = VALIDATORS[meta[0]](value)
tr_tool = getToolByName(self, 'portal_transforms')
# need to remap transform if necessary (i.e. configurable
# inputs / output)
if 'inputs' in kwargs or 'output' in kwargs:
tr_tool._unmapTransform(self)
if not hasattr(self, '_v_transform'):
self._load_transform()
self.inputs = kwargs.get('inputs', self._v_transform.inputs)
self.output = kwargs.get('output', self._v_transform.output)
tr_tool._mapTransform(self)
# track output encoding
if 'output_encoding' in kwargs:
self.output_encoding = kwargs['output_encoding']
if REQUEST is not None:
REQUEST['RESPONSE'].redirect(tr_tool.absolute_url() +
'/manage_main')
@security.protected(ManagePortal)
def reload(self):
""" reload the module where the transformation class is defined """
log('Reloading transform %s' % self.module)
m = import_from_name(self.module)
reload(m)
self._tr_init()
def preprocess_param(self, kwargs):
""" preprocess param fetched from an http post to handle
optional dictionary
"""
for param in self.get_parameters():
if self.get_parameter_infos(param)[0] == 'dict':
try:
keys = kwargs[param + '_key']
del kwargs[param + '_key']
except:
keys = ()
try:
values = kwargs[param + '_value']
del kwargs[param + '_value']
except:
values = ()
kwargs[param] = dict = {}
for key, value in zip(keys, values):
key = key.strip()
if key:
value = value.strip()
if value:
dict[key] = value
def update(self, dict):
"""update"""
UserDict.update(self, dict)
for key in dict.keys():
if key not in self._keys:
self._keys.append(key)
def update(self, dict):
self.lstKey.extend(dict.lstKey)
UserDict.update(self, dict)
def update(self, dict):
self.__populate()
UserDict.update( self, dict )
def update(self, d):
_dict.update(self, d)
self._dirty = 1
def update(self, dict):
for k in dict.keys():
if k not in self.data:
self._keys.append(k)
return BaseDict.update(self, dict)
def update(self,target): if isinstance(target,GetText): self.childrenlist.insert(0,target) else: UserDict.update(self,target)
def update(self, dict):
UserDict.update(self, dict)
for key in dict.keys():
if key not in self._keys:
self._keys.append(key)
def update(self, *args, **kwargs):
UserDict.update(self, *args, **kwargs)
self.save()
def update(self, dict):
UserDict.update(self, dict)
for key in list(dict.keys()):
if key not in self._keys: self._keys.append(key)
class Predictor(SimpleItem):
"""A predictor is an external method with
additional configuration information
"""
implements(IPredictor)
meta_type = 'Predictor'
meta_types = all_meta_types = ()
def __init__(self, id, module, predictor=None):
self.id = id
self.module = module
self._class = predictor.__class__.__name__
# DM 2004-09-09: 'Transform' instances are stored as
# part of a module level configuration structure
# Therefore, they must not contain persistent objects
self._config = UserDict()
self._config.__allow_access_to_unprotected_subobjects__ = 1
self._config_metadata = UserDict()
self._predictor_init(1, predictor)
def predictorclass(self):
""" """
return self.module + "." + self._class
def name(self):
"""return the name of the predictor instance"""
return self.id
def _predictor_init(self, set_conf=0, predictor=None):
""" """
__traceback_info__ = (self.module, )
if predictor is None:
predictor = self._load_predictor()
else:
self._v_predictor = predictor
# check this is a valid predictor
if not hasattr(predictor, '__class__'):
raise Plone4BioException(
'Invalid predictor : predictor is not a class')
if not IPredictor.providedBy(predictor):
raise Plone4BioException(
'Invalid predictor : IPredictor is not implemented by %s' %
predictor.__class__)
# if not hasattr(predictor, 'run'):
# raise Plone4BioException('Invalid predictor : missing required "run" attribute')
# manage configuration
if set_conf and hasattr(predictor, 'config'):
conf = dict(predictor.config)
self._config.update(conf)
make_config_persistent(self._config)
if hasattr(predictor, 'config_metadata'):
conf = dict(predictor.config_metadata)
self._config_metadata.update(conf)
make_config_persistent(self._config_metadata)
predictor.config = dict(self._config)
make_config_nonpersistent(predictor.config)
predictor.config_metadata = dict(self._config_metadata)
make_config_nonpersistent(predictor.config_metadata)
# self.inputs = predictor.inputs
# self.output = predictor.output
# self.output_encoding = getattr(predictor, 'output_encoding', None)
return predictor
def _load_predictor(self):
klass = self.predictorclass()
__traceback_info__ = klass
parts = klass.split('.')
if not parts:
raise ValueError, "incomplete klass name: %s" % klass
parts_copy = parts[:]
while parts_copy:
try:
module = __import__('.'.join(parts_copy))
break
except ImportError:
# Reraise if the import error was caused inside the imported file
if sys.exc_info()[2].tb_next is not None:
raise
del parts_copy[-1]
if not parts_copy:
return None
parts = parts[1:] # Funky semantics of __import__'s return value
obj = module
for part in parts:
try:
obj = getattr(obj, part)
except AttributeError:
return None
self._v_predictor = obj()
def run(self, obj, context=None, store=False, argv=([], {})):
""" """
assert type(argv[0]) == list
assert type(argv[1]) == dict
if not hasattr(self, '_v_predictor'):
self._load_predictor()
if ISeqRecord.providedBy(obj):
newseqr = self._v_predictor.run(obj.getSeqRecord(), *argv[0],
**argv[1])
if store:
#TODO: need locking?
obj.features = newseqr.features
#TODO: raise event
return obj
else:
return SeqRecord(newseqr.id,
title=newseqr.name,
seqrecord=newseqr)
else:
newseqr = self._v_predictor.run(obj, *argv[0], **argv[1])
if store:
obj.features = newseqr.features
return obj
else:
return newseqr
