Back to index

plone3  3.1.7
Public Member Functions | Public Attributes | Static Public Attributes | Private Member Functions | Private Attributes | Static Private Attributes
PortalTransforms.TransformEngine.TransformTool Class Reference
Inheritance diagram for PortalTransforms.TransformEngine.TransformTool:
Inheritance graph
[legend]
Collaboration diagram for PortalTransforms.TransformEngine.TransformTool:
Collaboration graph
[legend]

List of all members.

Public Member Functions

def __init__
def unregisterTransform
def convertTo
def convertToData
def convert
def __call__
def manage_afterAdd
def manage_addTransform
def manage_addTransformsChain
def manage_setCacheValidityTime
def reloadTransforms
def manage_addPolicy
def manage_delPolicies
def listPolicies
def registerTransform
def ZopeFind
def objectItems
def listAvailableTextInputs

Public Attributes

 max_sec_in_cache

Static Public Attributes

string id = 'portal_transforms'
tuple meta_type = id.title()
int isPrincipiaFolderish = 1
tuple meta_types
tuple manage_addTransformForm = PageTemplateFile('addTransform', _www)
tuple manage_addTransformsChainForm = PageTemplateFile('addTransformsChain', _www)
tuple manage_cacheForm = PageTemplateFile('setCacheTime', _www)
tuple manage_editTransformationPolicyForm = PageTemplateFile('editTransformationPolicy', _www)
tuple manage_reloadAllTransforms = PageTemplateFile('reloadAllTransforms', _www)
tuple manage_options
tuple security = ClassSecurityInfo()

Private Member Functions

def _setMetaData
def _wrap
def _unwrap
def _mapTransform
def _unmapTransform
def _findPath
def _getPaths

Private Attributes

 _mtmap
 _policies
 _new_style_pt

Static Private Attributes

 __implements__ = iengine

Detailed Description

Definition at line 37 of file TransformEngine.py.


Constructor & Destructor Documentation

def PortalTransforms.TransformEngine.TransformTool.__init__ (   self,
  policies = None,
  max_sec_in_cache = 3600 
)

Definition at line 72 of file TransformEngine.py.

00072 
00073     def __init__(self, policies=None, max_sec_in_cache=3600):
00074         self._mtmap = PersistentMapping()
00075         self._policies = policies or PersistentMapping()
00076         self.max_sec_in_cache = max_sec_in_cache
00077         self._new_style_pt = 1


Member Function Documentation

def PortalTransforms.TransformEngine.TransformTool.__call__ (   self,
  name,
  orig,
  data = None,
  context = None,
  kwargs 
)
run a transform by its name, returning the raw data product

* name is the name of a registered transform.

return an encoded string.
see convert docstring for more info on additional arguments.

Definition at line 222 of file TransformEngine.py.

00222 
00223     def __call__(self, name, orig, data=None, context=None, **kwargs):
00224         """run a transform by its name, returning the raw data product
00225 
00226         * name is the name of a registered transform.
00227 
00228         return an encoded string.
00229         see convert docstring for more info on additional arguments.
00230         """
00231         data = self.convert(name, orig, data, context, **kwargs)
00232         return data.getData()
00233 

Here is the call graph for this function:

def PortalTransforms.TransformEngine.TransformTool._findPath (   self,
  orig,
  target,
  required_transforms = () 
) [private]
return the shortest path for transformation from orig mimetype to
target mimetype

Definition at line 313 of file TransformEngine.py.

00313 
00314     def _findPath(self, orig, target, required_transforms=()):
00315         """return the shortest path for transformation from orig mimetype to
00316         target mimetype
00317         """
00318         path = []
00319 
00320         if not self._mtmap:
00321             return None
00322 
00323         # naive algorithm :
00324         #  find all possible paths with required transforms
00325         #  take the shortest
00326         #
00327         # it should be enough since we should not have so much possible paths
00328         shortest, winner = 9999, None
00329         for path in self._getPaths(str(orig), str(target), required_transforms):
00330             if len(path) < shortest:
00331                 winner = path
00332                 shortest = len(path)
00333 
00334         return winner

Here is the call graph for this function:

Here is the caller graph for this function:

def PortalTransforms.TransformEngine.TransformTool._getPaths (   self,
  orig,
  target,
  requirements,
  path = None,
  result = None 
) [private]
return a all path for transformation from orig mimetype to
target mimetype

Definition at line 335 of file TransformEngine.py.

00335 
00336     def _getPaths(self, orig, target, requirements, path=None, result=None):
00337         """return a all path for transformation from orig mimetype to
00338         target mimetype
00339         """
00340         if path is None:
00341             result = []
00342             path = []
00343             requirements = list(requirements)
00344         outputs = self._mtmap.get(orig)
00345         if outputs is None:
00346             return result
00347         path.append(None)
00348         for o_mt, transforms in outputs.items():
00349             for transform in transforms:
00350                 required = 0
00351                 name = transform.name()
00352                 if name in requirements:
00353                     requirements.remove(name)
00354                     required = 1
00355                 if transform in path:
00356                     # avoid infinite loop...
00357                     continue
00358                 path[-1] = transform
00359                 if o_mt == target:
00360                     if not requirements:
00361                         result.append(path[:])
00362                 else:
00363                     self._getPaths(o_mt, target, requirements, path, result)
00364                 if required:
00365                     requirements.append(name)
00366         path.pop()
00367 
00368         return result

Here is the call graph for this function:

Here is the caller graph for this function:

def PortalTransforms.TransformEngine.TransformTool._mapTransform (   self,
  transform 
) [private]
map transform to internal structures

Definition at line 255 of file TransformEngine.py.

00255 
00256     def _mapTransform(self, transform):
00257         """map transform to internal structures"""
00258         registry = getToolByName(self, 'mimetypes_registry')
00259         inputs = getattr(transform, 'inputs', None)
00260         if not inputs:
00261             raise TransformException('Bad transform %s : no input MIME type' %
00262                                      (transform))
00263         for i in inputs:
00264             mts = registry.lookup(i)
00265             if not mts:
00266                 msg = 'Input MIME type %r for transform %s is not registered '\
00267                       'in the MIME types registry' % (i, transform.name())
00268                 raise TransformException(msg)
00269             for mti in mts:
00270                 for mt in mti.mimetypes:
00271                     mt_in = self._mtmap.setdefault(mt, PersistentMapping())
00272                     output = getattr(transform, 'output', None)
00273                     if not output:
00274                         msg = 'Bad transform %s : no output MIME type'
00275                         raise TransformException(msg % transform.name())
00276                     mto = registry.lookup(output)
00277                     if not mto:
00278                         msg = 'Output MIME type %r for transform %s is not '\
00279                               'registered in the MIME types registry' % \
00280                               (output, transform.name())
00281                         raise TransformException(msg)
00282                     if len(mto) > 1:
00283                         msg = 'Wildcarding not allowed in transform\'s output '\
00284                               'MIME type'
00285                         raise TransformException(msg)
00286 
00287                     for mt2 in mto[0].mimetypes:
00288                         try:
00289                             if not transform in mt_in[mt2]:
00290                                 mt_in[mt2].append(transform)
00291                         except KeyError:
00292                             mt_in[mt2] = PersistentList([transform])

Here is the call graph for this function:

Here is the caller graph for this function:

def PortalTransforms.TransformEngine.TransformTool._setMetaData (   self,
  datastream,
  transform 
) [private]
set metadata on datastream according to the given transform
(mime type and optionaly encoding)

Definition at line 236 of file TransformEngine.py.

00236 
00237     def _setMetaData(self, datastream, transform):
00238         """set metadata on datastream according to the given transform
00239         (mime type and optionaly encoding)
00240         """
00241         md = datastream.getMetadata()
00242         if hasattr(transform, 'output_encoding'):
00243             md['encoding'] = transform.output_encoding
00244         md['mimetype'] = transform.output

Here is the caller graph for this function:

def PortalTransforms.TransformEngine.TransformTool._unmapTransform (   self,
  transform 
) [private]
unmap transform from internal structures

Definition at line 293 of file TransformEngine.py.

00293 
00294     def _unmapTransform(self, transform):
00295         """unmap transform from internal structures"""
00296         registry = getToolByName(self, 'mimetypes_registry')
00297         for i in transform.inputs:
00298             for mti in registry.lookup(i):
00299                 for mt in mti.mimetypes:
00300                     mt_in = self._mtmap.get(mt, {})
00301                     output = transform.output
00302                     mto = registry.lookup(output)
00303                     for mt2 in mto[0].mimetypes:
00304                         l = mt_in[mt2]
00305                         for i in range(len(l)):
00306                             if transform.name() == l[i].name():
00307                                 l.pop(i)
00308                                 break
00309                         else:
00310                             log('Can\'t find transform %s from %s to %s' % (
00311                                 transform.name(), mti, mt),
00312                                 severity=DEBUG)

Here is the call graph for this function:

Here is the caller graph for this function:

def PortalTransforms.TransformEngine.TransformTool._unwrap (   self,
  data 
) [private]
unwrap data from an icache

Definition at line 249 of file TransformEngine.py.

00249 
00250     def _unwrap(self, data):
00251         """unwrap data from an icache"""
00252         if idatastream.isImplementedBy(data):
00253             data = data.getData()
00254         return data

def PortalTransforms.TransformEngine.TransformTool._wrap (   self,
  name 
) [private]
wrap a data object in an icache

Definition at line 245 of file TransformEngine.py.

00245 
00246     def _wrap(self, name):
00247         """wrap a data object in an icache"""
00248         return datastream(name)

Here is the caller graph for this function:

def PortalTransforms.TransformEngine.TransformTool.convert (   self,
  name,
  orig,
  data = None,
  context = None,
  kwargs 
)
run a tranform of a given name on data

* name is the name of a registered transform

see convertTo docstring for more info

Definition at line 204 of file TransformEngine.py.

00204 
00205     def convert(self, name, orig, data=None, context=None, **kwargs):
00206         """run a tranform of a given name on data
00207 
00208         * name is the name of a registered transform
00209 
00210         see convertTo docstring for more info
00211         """
00212         if not data:
00213             data = self._wrap(name)
00214         try:
00215             transform = getattr(self, name)
00216         except AttributeError:
00217             raise Exception('No such transform "%s"' % name)
00218         data = transform.convert(orig, data, context=context, **kwargs)
00219         self._setMetaData(data, transform)
00220         return data
00221 

Here is the call graph for this function:

Here is the caller graph for this function:

def PortalTransforms.TransformEngine.TransformTool.convertTo (   self,
  target_mimetype,
  orig,
  data = None,
  object = None,
  usedby = None,
  context = None,
  kwargs 
)
Convert orig to a given mimetype

* orig is an encoded string

* data an optional idatastream object. If None a new datastream will be
created and returned

* optional object argument is the object on which is bound the data.
If present that object will be used by the engine to bound cached data.

* additional arguments (kwargs) will be passed to the transformations.
Some usual arguments are : filename, mimetype, encoding

return an object implementing idatastream or None if no path has been
found.

Definition at line 90 of file TransformEngine.py.

00090 
00091                   usedby=None, context=None, **kwargs):
00092         """Convert orig to a given mimetype
00093 
00094         * orig is an encoded string
00095 
00096         * data an optional idatastream object. If None a new datastream will be
00097         created and returned
00098 
00099         * optional object argument is the object on which is bound the data.
00100         If present that object will be used by the engine to bound cached data.
00101 
00102         * additional arguments (kwargs) will be passed to the transformations.
00103         Some usual arguments are : filename, mimetype, encoding
00104 
00105         return an object implementing idatastream or None if no path has been
00106         found.
00107         """
00108         target_mimetype = str(target_mimetype)
00109 
00110         if object is not None:
00111             cache = Cache(object)
00112             data = cache.getCache(target_mimetype)
00113             if data is not None:
00114                 time, data = data
00115                 if self.max_sec_in_cache == 0 or time < self.max_sec_in_cache:
00116                     return data
00117 
00118         if data is None:
00119             data = self._wrap(target_mimetype)
00120 
00121         registry = getToolByName(self, 'mimetypes_registry')
00122 
00123         if not getattr(aq_base(registry), 'classify', None):
00124             # avoid problems when importing a site with an old mimetype registry
00125             # XXX return None or orig?
00126             return None
00127 
00128         orig_mt = registry.classify(orig,
00129                                     mimetype=kwargs.get('mimetype'),
00130                                     filename=kwargs.get('filename'))
00131         orig_mt = str(orig_mt)
00132         if not orig_mt:
00133             log('Unable to guess input mime type (filename=%s, mimetype=%s)' %(
00134                 kwargs.get('mimetype'), kwargs.get('filename')), severity=DEBUG)
00135             return None
00136 
00137         target_mt = registry.lookup(target_mimetype)
00138         if target_mt:
00139             target_mt = target_mt[0]
00140         else:
00141             log('Unable to match target mime type %s'% str(target_mimetype),
00142                 severity=DEBUG)
00143             return None
00144 
00145         ## fastpath
00146         # If orig_mt and target_mt are the same, we only allow
00147         # a one-hop transform, a.k.a. filter.
00148         # XXX disabled filtering for now
00149         filter_only = False
00150         if orig_mt == str(target_mt):
00151             filter_only = True
00152             data.setData(orig)
00153             md = data.getMetadata()
00154             md['mimetype'] = str(orig_mt)
00155             if object is not None:
00156                 cache.setCache(str(target_mimetype), data)
00157             return data
00158 
00159         ## get a path to output mime type
00160         requirements = self._policies.get(str(target_mt), [])
00161         path = self._findPath(orig_mt, target_mt, list(requirements))
00162         if not path and requirements:
00163             log('Unable to satisfy requirements %s' % ', '.join(requirements),
00164                 severity=DEBUG)
00165             path = self._findPath(orig_mt, target_mt)
00166 
00167         if not path:
00168             log('NO PATH FROM %s TO %s : %s' % (orig_mt, target_mimetype, path),
00169                 severity=DEBUG)
00170             return None #XXX raise TransformError
00171 
00172         if len(path) > 1:
00173             ## create a chain on the fly (sly)
00174             transform = chain()
00175             for t in path:
00176                 transform.registerTransform(t)
00177         else:
00178             transform = path[0]
00179 
00180         result = transform.convert(orig, data, context=context, usedby=usedby, **kwargs)
00181         assert(idatastream.isImplementedBy(result),
00182                'result doesn\'t implemented idatastream')
00183         self._setMetaData(result, transform)
00184 
00185         # set cache if possible
00186         if object is not None and result.isCacheable():
00187             cache.setCache(str(target_mimetype), result)
00188 
00189         # return idatastream object
00190         return result

Here is the call graph for this function:

Here is the caller graph for this function:

def PortalTransforms.TransformEngine.TransformTool.convertToData (   self,
  target_mimetype,
  orig,
  data = None,
  object = None,
  usedby = None,
  context = None,
  kwargs 
)
Convert to a given mimetype and return the raw data
ignoring subobjects. see convertTo for more information

Definition at line 193 of file TransformEngine.py.

00193 
00194                       usedby=None, context=None, **kwargs):
00195         """Convert to a given mimetype and return the raw data
00196         ignoring subobjects. see convertTo for more information
00197         """
00198         data =self.convertTo(target_mimetype, orig, data, object, usedby,
00199                        context, **kwargs)
00200         if data:
00201             return data.getData()
00202         return None

Here is the call graph for this function:

Here is the caller graph for this function:

Returns a list of mimetypes that can be used as input for textfields
    by building a list of the inputs beginning with "text/" of all transforms.

Definition at line 499 of file TransformEngine.py.

00499 
00500     def listAvailableTextInputs(self):
00501         """ Returns a list of mimetypes that can be used as input for textfields
00502             by building a list of the inputs beginning with "text/" of all transforms.
00503         """
00504         available_types = []
00505         candidate_transforms = [object[1] for object in self.objectItems()]
00506         for candidate in candidate_transforms:
00507             for input in candidate.inputs:
00508                 if input.startswith("text/") and input not in available_types:
00509                     available_types.append(input)
00510         return available_types
00511 
00512 InitializeClass(TransformTool)
00513 registerToolInterface('portal_transforms', IPortalTransformsTool)

Here is the call graph for this function:

return the list of defined policies

a policy is a 2-uple (output_mime_type, [list of required transforms])

Definition at line 449 of file TransformEngine.py.

00449 
00450     def listPolicies(self):
00451         """ return the list of defined policies
00452 
00453         a policy is a 2-uple (output_mime_type, [list of required transforms])
00454         """
00455         # XXXFIXME: backward compat, should be removed latter
00456         if not hasattr(self, '_policies'):
00457             self._policies = PersistentMapping()
00458         return self._policies.items()

def PortalTransforms.TransformEngine.TransformTool.manage_addPolicy (   self,
  output_mimetype,
  required_transforms,
  REQUEST = None 
)
add a policy for a given output mime types

Definition at line 428 of file TransformEngine.py.

00428 
00429     def manage_addPolicy(self, output_mimetype, required_transforms, REQUEST=None):
00430         """ add a policy for a given output mime types"""
00431         registry = getToolByName(self, 'mimetypes_registry')
00432         if not registry.lookup(output_mimetype):
00433             raise TransformException('Unknown MIME type')
00434         if self._policies.has_key(output_mimetype):
00435             msg = 'A policy for output %s is yet defined' % output_mimetype
00436             raise TransformException(msg)
00437 
00438         required_transforms = tuple(required_transforms)
00439         self._policies[output_mimetype] = required_transforms
00440         if REQUEST is not None:
00441             REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_editTransformationPolicyForm')

Here is the call graph for this function:

def PortalTransforms.TransformEngine.TransformTool.manage_addTransform (   self,
  id,
  module,
  REQUEST = None 
)
add a new transform to the tool 

Definition at line 385 of file TransformEngine.py.

00385 
00386     def manage_addTransform(self, id, module, REQUEST=None):
00387         """ add a new transform to the tool """
00388         transform = Transform(id, module)
00389         self._setObject(id, transform)
00390         self._mapTransform(transform)
00391         if REQUEST is not None:
00392             REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')

Here is the call graph for this function:

def PortalTransforms.TransformEngine.TransformTool.manage_addTransformsChain (   self,
  id,
  description,
  REQUEST = None 
)
add a new transform to the tool 

Definition at line 394 of file TransformEngine.py.

00394 
00395     def manage_addTransformsChain(self, id, description, REQUEST=None):
00396         """ add a new transform to the tool """
00397         transform = TransformsChain(id, description)
00398         self._setObject(id, transform)
00399         self._mapTransform(transform)
00400         if REQUEST is not None:
00401             REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')

Here is the call graph for this function:

def PortalTransforms.TransformEngine.TransformTool.manage_afterAdd (   self,
  item,
  container 
)
overload manage_afterAdd to finish initialization when the
transform tool is added

Definition at line 370 of file TransformEngine.py.

00370 
00371     def manage_afterAdd(self, item, container):
00372         """ overload manage_afterAdd to finish initialization when the
00373         transform tool is added
00374         """
00375         Folder.manage_afterAdd(self, item, container)
00376         transforms.initialize(self)
00377         # XXX required?
00378         #try:
00379         #    # first initialization
00380         #    transforms.initialize(self)
00381         #except:
00382         #    # may fail on copy
00383         #    pass

def PortalTransforms.TransformEngine.TransformTool.manage_delPolicies (   self,
  outputs,
  REQUEST = None 
)
remove policies for given output mime types

Definition at line 442 of file TransformEngine.py.

00442 
00443     def manage_delPolicies(self, outputs, REQUEST=None):
00444         """ remove policies for given output mime types"""
00445         for mimetype in outputs:
00446             del self._policies[mimetype]
00447         if REQUEST is not None:
00448             REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_editTransformationPolicyForm')

Here is the call graph for this function:

def PortalTransforms.TransformEngine.TransformTool.manage_setCacheValidityTime (   self,
  seconds,
  REQUEST = None 
)
set  the lifetime of cached data in seconds

Definition at line 403 of file TransformEngine.py.

00403 
00404     def manage_setCacheValidityTime(self, seconds, REQUEST=None):
00405         """set  the lifetime of cached data in seconds"""
00406         self.max_sec_in_cache = int(seconds)
00407         if REQUEST is not None:
00408             REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')

Here is the call graph for this function:

def PortalTransforms.TransformEngine.TransformTool.objectItems (   self,
  args,
  kwargs 
)
Don't break ZopeFind feature when a transform can't be loaded

Definition at line 489 of file TransformEngine.py.

00489 
00490     def objectItems(self, *args, **kwargs):
00491         """Don't break ZopeFind feature when a transform can't be loaded
00492         """
00493         try:
00494             return Folder.objectItems(self, *args, **kwargs)
00495         except MissingBinary:
00496             log('objectItems: catched MissingBinary exception')
00497             return []

Here is the caller graph for this function:

register a new transform

transform isn't a Zope Transform (the wrapper) but the wrapped transform
the persistence wrapper will be created here

Definition at line 461 of file TransformEngine.py.

00461 
00462     def registerTransform(self, transform):
00463         """register a new transform
00464 
00465         transform isn't a Zope Transform (the wrapper) but the wrapped transform
00466         the persistence wrapper will be created here
00467         """
00468         # needed when call from transform.transforms.initialize which
00469         # register non zope transform
00470         module = str(transform.__module__)
00471         transform = Transform(transform.name(), module, transform)
00472         if not itransform.isImplementedBy(transform):
00473             raise TransformException('%s does not implement itransform' % transform)
00474         name = transform.name()
00475         __traceback_info__ = (name, transform)
00476         if name not in self.objectIds():
00477             self._setObject(name, transform)
00478             self._mapTransform(transform)

Here is the call graph for this function:

reload transforms with the given ids
if no ids, reload all registered transforms

return a list of (transform_id, transform_module) describing reloaded
transforms

Definition at line 410 of file TransformEngine.py.

00410 
00411     def reloadTransforms(self, ids=()):
00412         """ reload transforms with the given ids
00413         if no ids, reload all registered transforms
00414 
00415         return a list of (transform_id, transform_module) describing reloaded
00416         transforms
00417         """
00418         if not ids:
00419             ids = self.objectIds()
00420         reloaded = []
00421         for id in ids:
00422             o = getattr(self, id)
00423             o.reload()
00424             reloaded.append((id, o.module))
00425         return reloaded

Here is the call graph for this function:

unregister a transform
name is the name of a registered transform

Definition at line 80 of file TransformEngine.py.

00080 
00081     def unregisterTransform(self, name):
00082         """ unregister a transform
00083         name is the name of a registered transform
00084         """
00085         self._unmapTransform(getattr(self, name))
00086         if name in self.objectIds():
00087             self._delObject(name)
00088 

Here is the call graph for this function:

def PortalTransforms.TransformEngine.TransformTool.ZopeFind (   self,
  args,
  kwargs 
)
Don't break ZopeFind feature when a transform can't be loaded

Definition at line 480 of file TransformEngine.py.

00480 
00481     def ZopeFind(self, *args, **kwargs):
00482         """Don't break ZopeFind feature when a transform can't be loaded
00483         """
00484         try:
00485             return Folder.ZopeFind(self, *args, **kwargs)
00486         except MissingBinary:
00487             log('ZopeFind: catched MissingBinary exception')


Member Data Documentation

Definition at line 43 of file TransformEngine.py.

Definition at line 73 of file TransformEngine.py.

Definition at line 76 of file TransformEngine.py.

Definition at line 74 of file TransformEngine.py.

string PortalTransforms.TransformEngine.TransformTool.id = 'portal_transforms' [static]

Definition at line 39 of file TransformEngine.py.

Definition at line 41 of file TransformEngine.py.

tuple PortalTransforms.TransformEngine.TransformTool.manage_addTransformForm = PageTemplateFile('addTransform', _www) [static]

Definition at line 53 of file TransformEngine.py.

tuple PortalTransforms.TransformEngine.TransformTool.manage_addTransformsChainForm = PageTemplateFile('addTransformsChain', _www) [static]

Definition at line 54 of file TransformEngine.py.

tuple PortalTransforms.TransformEngine.TransformTool.manage_cacheForm = PageTemplateFile('setCacheTime', _www) [static]

Definition at line 55 of file TransformEngine.py.

tuple PortalTransforms.TransformEngine.TransformTool.manage_editTransformationPolicyForm = PageTemplateFile('editTransformationPolicy', _www) [static]

Definition at line 56 of file TransformEngine.py.

Initial value:
((Folder.manage_options[0],) + Folder.manage_options[2:] +
                      (
        { 'label'   : 'Caches',
          'action' : 'manage_cacheForm'},
        { 'label'   : 'Policy',
          'action' : 'manage_editTransformationPolicyForm'},
        { 'label'   : 'Reload transforms',
          'action' : 'manage_reloadAllTransforms'},
        )
                      )

Definition at line 59 of file TransformEngine.py.

tuple PortalTransforms.TransformEngine.TransformTool.manage_reloadAllTransforms = PageTemplateFile('reloadAllTransforms', _www) [static]

Definition at line 57 of file TransformEngine.py.

Definition at line 75 of file TransformEngine.py.

Definition at line 40 of file TransformEngine.py.

Initial value:
all_meta_types(
        { 'name'   : 'Transform',
          'action' : 'manage_addTransformForm'},
        { 'name'   : 'TransformsChain',
          'action' : 'manage_addTransformsChainForm'},
        )

Definition at line 46 of file TransformEngine.py.

tuple PortalTransforms.TransformEngine.TransformTool.security = ClassSecurityInfo() [static]

Definition at line 70 of file TransformEngine.py.


The documentation for this class was generated from the following file: