def manage_addPolicy(self, output_mimetype, required_transforms,
REQUEST=None):
""" add a policy for a given output mime types"""
registry = getToolByName(self, 'mimetypes_registry')
if not registry.lookup(output_mimetype):
raise TransformException('Unknown MIME type')
if output_mimetype in self._policies:
msg = 'A policy for output %s is yet defined' % output_mimetype
raise TransformException(msg)
required_transforms = tuple(required_transforms)
self._policies[output_mimetype] = required_transforms
if REQUEST is not None:
REQUEST['RESPONSE'].redirect(self.absolute_url() +
'/manage_editTransformationPolicyForm')
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
def install_tika_policy(util, logger):
"""Install the transform policy for the tika_to_plain_text transform.
If this policy is already present from an earlier install, remove and
re-register it. If another policy for this output MIME type is present,
bail with a decent error message.
"""
output_mimetype = 'text/plain'
required_transform = TIKA_TRANSFORM_NAME
transform_tool = getUtility(IPortalTransformsTool)
policies = [(mimetype, required)
for (mimetype, required) in transform_tool.listPolicies()
if mimetype == output_mimetype]
if len(policies) == 1 and policies[0][1] == (required_transform, ):
# That's our own policy (from a previous install)
# Unregister it before registering it again
util.unregister_transform_policy(output_mimetype)
try:
util.register_transform_policy(output_mimetype, TIKA_TRANSFORM_NAME)
except TransformException:
logger.error("There is already a transform policy for '%s' installed! "
"Please remove it first using the portal_transforms tool "
"before attempting to install ftw.tika." %
output_mimetype)
raise TransformException(
"A policy for 'text/plain' already exists - please uninstall "
"it first if you want to install ftw.tika.")
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 _mapTransform(self, transform):
"""map transform to internal structures"""
registry = getToolByName(self, 'mimetypes_registry')
inputs = getattr(transform, 'inputs', None)
if not inputs:
raise TransformException('Bad transform %s : no input MIME type' %
(transform))
for i in inputs:
mts = registry.lookup(i)
if not mts:
msg = 'Input MIME type %r for transform %s is not registered '\
'in the MIME types registry' % (i, transform.name())
raise TransformException(msg)
for mti in mts:
for mt in mti.mimetypes:
mt_in = self._mtmap.setdefault(mt, PersistentMapping())
output = getattr(transform, 'output', None)
if not output:
msg = 'Bad transform %s : no output MIME type'
raise TransformException(msg % transform.name())
mto = registry.lookup(output)
if not mto:
msg = 'Output MIME type %r for transform %s is not '\
'registered in the MIME types registry' % \
(output, transform.name())
raise TransformException(msg)
if len(mto) > 1:
msg = ("Wildcarding not allowed in transform's output "
"MIME type")
raise TransformException(msg)
for mt2 in mto[0].mimetypes:
try:
if not transform in mt_in[mt2]:
mt_in[mt2].append(transform)
except KeyError:
mt_in[mt2] = PersistentList([transform])
def registerTransform(self, transform):
"""register a new transform
transform isn't a Zope Transform (the wrapper) but the wrapped
transform the persistence wrapper will be created here
"""
# needed when call from transform.transforms.initialize which
# register non zope transform
module = str(transform.__module__)
transform = Transform(transform.name(), module, transform)
if not ITransform.providedBy(transform):
raise TransformException('%s does not implement ITransform' %
transform)
name = transform.name()
__traceback_info__ = (name, transform)
if name not in self.objectIds():
self._setObject(name, transform)
self._mapTransform(transform)
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)
