[Erp5-report] r9216 - /erp5/trunk/utils/ooodoc_server/

nobody at svn.erp5.org nobody at svn.erp5.org
Tue Aug 15 16:12:08 CEST 2006


Author: bartek
Date: Tue Aug 15 16:12:04 2006
New Revision: 9216

URL: http://svn.erp5.org?rev=9216&view=rev
Log:
major refactoring - consistent interface, values passed around as one dictionary

Modified:
    erp5/trunk/utils/ooodoc_server/serw.py
    erp5/trunk/utils/ooodoc_server/test_server.py
    erp5/trunk/utils/ooodoc_server/test_worker.py
    erp5/trunk/utils/ooodoc_server/worker.py

Modified: erp5/trunk/utils/ooodoc_server/serw.py
URL: http://svn.erp5.org/erp5/trunk/utils/ooodoc_server/serw.py?rev=9216&r1=9215&r2=9216&view=diff
==============================================================================
--- erp5/trunk/utils/ooodoc_server/serw.py (original)
+++ erp5/trunk/utils/ooodoc_server/serw.py Tue Aug 15 16:12:04 2006
@@ -46,9 +46,9 @@
 class Procesor(object):
   '''main request handler, registered with the server handler
   functions are auto-generated named run_<funcname>, args:
-  filename, data, [metadata],*args, **kwargs 
-  one of the **kwargs can be format (target format, default=appropriate
-  OOo format)'''
+  filename, data, [metadata, extension]
+  (only positional args are supported - this is xmlrpclib limitation)
+  '''
   
   public_funcs=('convert','getmetadata','setmetadata','generate','getmetadatatoolong')
 
@@ -70,30 +70,30 @@
     '''
     return os.path.join(config.basedir,'tmp',fname)
 
-  def convert(self,w,fname,*args,**kwargs):
-    meta,newfname=w.run_convert(fname,**kwargs)
-    return meta,newfname
+  def convert(self,w,kw):
+    w.run_convert(kw)
+    return True
   
-  def getmetadatatoolong(self,w,fname,*args,**kwargs):
-    meta=w.run_getmetadatatoolong(fname)
+  def getmetadatatoolong(self,w,kw):
+    w.run_getmetadatatoolong(kw)
+    return True
+
+  def getmetadata(self,w,kw):
+    meta=w.run_getmetadata(kw)
     return meta,None
 
-  def getmetadata(self,w,fname,*args,**kwargs):
-    meta=w.run_getmetadata(fname)
-    return meta,None
-
-  def setmetadata(self,w,fname,meta,*args,**kwargs):
-    res=w.run_setmetadata(fname,meta)
+  def setmetadata(self,w,kw):
+    res=w.run_setmetadata(kw)
     if res:
-      return meta,fname
+      return True
     else:
       raise lib.SetMetaFailed()
 
-  def generate(self,w,fname,format,**kwargs):
+  def generate(self,w,kw):
     '''generate file in a desired format (provided we already
     have an OOo file)'''
-    meta,newfname=w.run_generate(fname,format)
-    return meta,newfname
+    w.run_generate(kw)
+    return True
 
   def getAllowedTargets(self,mimetype):
     '''get list of allowed target formats from worker
@@ -104,31 +104,36 @@
     finally:
       w.setFree()
 
-  def _pre(self,name,data):
+  def _pre(self,kw):
     '''write data to a temp file, get worker instance'''
     id,w=pool.pool.getWorker()
-    fname='%d_%s' % (id,name) # in case we have two files of the same name
-    fname=self._mkName(fname)
-    f=open(fname,'w')
-    f2=open(self._mkName('temp64'),'w')
-    f2.write(data)
-    f.write(base64.decodestring(data))
-    f.close()
-    f2.close()
-    return w,fname
+    if kw.get('data') is not None and kw['data']!='':
+      if kw.get('filename') is None:
+        # we could generate a random name here
+        raise lib.ServerException('data is set, but filename is not')
+      filename='%d_%s' % (id,self._asciify(kw['filename'])) # in case we have two files of the same name
+      filename=self._mkName(filename)
+      f=open(filename,'w')
+      f2=open(self._mkName('temp64'),'w')
+      f2.write(kw['data'])
+      f.write(base64.decodestring(kw['data']))
+      f.close()
+      f2.close()
+      kw['filename']=filename
+    return w
 
-  def _safeRemove(self,fname):
+  def _safeRemove(self,filename):
     '''remove a file or log warning if none exists'''
     any=False
     for f in os.listdir(os.path.join(config.basedir,'tmp')):
-      if f.startswith(os.path.basename(fname)): # html formats generate a number of files
+      if f.startswith(os.path.basename(filename)): # html formats generate a number of files
         lib.log('removing %s' % f)
         #os.remove(self._mkName(f))
         any=True
     if not any:
-      lib.log('no file beginning with %s' % fname,1)
+      lib.log('no file beginning with %s' % filename,1)
 
-  def _post(self,w,fname,newfname=None):
+  def _post(self,w,kw):
     '''
     remove temp files, free worker
     newfname only if there was convertion
@@ -136,10 +141,10 @@
     try:
       # because we are in finally, things can be none
       # if there was an exception
-      if fname is not None:
-        self._safeRemove(self._mkName(fname))
-      if newfname is not None:
-        self._safeRemove(self._mkName(newfname))
+      if kw.get('filename') is not None:
+        self._safeRemove(self._mkName(kw['filename']))
+      if kw.get('newfilename') is not None:
+        self._safeRemove(self._mkName(kw['newfilename']))
     finally:
       if w is not None: 
         w.setFree()
@@ -149,41 +154,42 @@
     which means there was a convertion, send data back to the
     user
     '''
-    def _run(name,data,meta=None,**kwargs):
-      fname=newfname=w=None # or in case of exception we get UnboundLocalError
+    argtpl=('filename','data','meta','extension')
+    def _run(*args):
+      kw=dict(zip(argtpl,args))
       try:
         try:
-          name=self._asciify(name)
-          w,fname=self._pre(name,data)
-          format=meta # when generating, this argument is a target format (grrr...)
-                      # we need to store it to figure out whether to zip
-          meta,newfname=func(w,fname,meta,**kwargs)
-          if newfname is None:
+          w=self._pre(kw)
+          print 'running',func.__name__
+          res=func(w,kw) # XXX am I sure it is threadsafe?
+          if kw.get('newfilename') is None:
             # we return empty data
-            data=''
+            kw['data']=''
           else:
             try: # we can do it only if the argument is a string
-              zip=format.startswith('html') # if html, we pack the output files
+              tozip=kw.get('extension').startswith('html') # if html, we pack the output files
             except AttributeError:
-              zip=False
-            if zip:
+              tozip=False
+            if tozip:
                 #first delete the original
+                # XXX rewrite to use zipfile
+                fname=kw['filename']
                 os.remove(self._mkName(fname))
                 zipname=self._mkName(fname+'.zip')
                 zipwildcard=self._mkName(fname+'*')
                 cmd='zip -j %s %s' % (zipname,zipwildcard)
                 res=os.system(cmd)
                 data=base64.encodestring(open(zipname).read())
-                meta='application/zip' # generation returns mime type
+                kw['mime']='application/zip' # generation returns mime type
             else:
-              data=base64.encodestring(open(self._mkName(newfname)).read())
-          return (meta,data)
+              kw['data']=base64.encodestring(open(self._mkName(kw['newfilename'])).read())
+          return kw
         except Exception,e:
           print e
           traceback.print_tb(sys.exc_info()[2])
           raise e
       finally:
-        self._post(w,fname,newfname)
+        self._post(w,kw)
     func=getattr(self,funcname)
     return _run
 

Modified: erp5/trunk/utils/ooodoc_server/test_server.py
URL: http://svn.erp5.org/erp5/trunk/utils/ooodoc_server/test_server.py?rev=9216&r1=9215&r2=9216&view=diff
==============================================================================
--- erp5/trunk/utils/ooodoc_server/test_server.py (original)
+++ erp5/trunk/utils/ooodoc_server/test_server.py Tue Aug 15 16:12:04 2006
@@ -44,62 +44,59 @@
 
 class TestMetaOperations(unittest.TestCase):
 
-    def testSetGetMeta(self):
-        # setting metadata
-        mime='application/vnd.oasis.opendocument.text'
-        newmeta={'Title':'HELLOOOOOO','Reference':'blaaaaaah','MIMEType':mime}
-        data=open('doc/test.odt').read()
-        res=sp.run_setmetadata('test.odt',base64.encodestring(data),newmeta)
-        open('doc/test_changed.odt','w').write(base64.decodestring(res[1]))
-        # getting metadata back after the change
-        data=open('doc/test_changed.odt').read()
-        res=sp.run_getmetadata('test_changed.odt',base64.encodestring(data))
-        self.assertEqual(res[0]['Title'],'HELLOOOOOO')
-        self.assertEqual(res[0]['Reference'],'blaaaaaah')
+  def testSetGetMeta(self):
+    # setting metadata
+    mime='application/vnd.oasis.opendocument.text'
+    newmeta={'title':'HELLOOOOOO','reference':'blaaaaaah','MIMEType':mime}
+    data=open('doc/test.odt').read()
+    res=sp.run_setmetadata('test.odt',base64.encodestring(data),newmeta)
+    open('doc/test_changed.odt','w').write(base64.decodestring(res['data']))
+    # getting metadata back after the change
+    data=open('doc/test_changed.odt').read()
+    res=sp.run_getmetadata('test_changed.odt',base64.encodestring(data))
+    self.assertEqual(res['meta']['title'],'HELLOOOOOO')
+    self.assertEqual(res['meta']['reference'],'blaaaaaah')
 
 class TestFileOperations(unittest.TestCase):
 
   def testConvertDoc(self):
     data=open('doc/test.doc').read()
     res=sp.run_convert('test.doc',base64.encodestring(data))
-    open('doc/test.odt','w').write(base64.decodestring(res[1]))
+    self.assertEqual(res['mime'],'application/vnd.oasis.opendocument.text')
+    open('doc/test.odt','w').write(base64.decodestring(res['data']))
 
   def testConvertXls(self):
     data=open('doc/test.xls').read()
     res=sp.run_convert('test.xls',base64.encodestring(data))
-    open('doc/test.ods','w').write(base64.decodestring(res[1]))
+    self.assertEqual(res['mime'],'application/vnd.oasis.opendocument.spreadsheet')
+    open('doc/test.ods','w').write(base64.decodestring(res['data']))
 
   def testConvertPpt(self):
     data=open('doc/test.ppt').read()
     res=sp.run_convert('test.ppt',base64.encodestring(data))
-    open('doc/test.odp','w').write(base64.decodestring(res[1]))
+    self.assertEqual(res['mime'],'application/vnd.oasis.opendocument.presentation')
+    open('doc/test.odp','w').write(base64.decodestring(res['data']))
 
   def testPdfTextGeneration(self):
-    try:
-      data=open('doc/test.odt').read()
-      res=sp.run_generate('test.odt',enc(data),'pdf')
-      self.assert_(res)
-      open('doc/test.pdf','w').write(base64.decodestring(res[1]))
-    except Fault,e:
-      print e
+    data=open('doc/test.odt').read()
+    res=sp.run_generate('test.odt',enc(data),None,'pdf')
+    self.assert_(res)
+    self.assertEqual(res['mime'],'application/pdf')
+    open('doc/test.pdf','w').write(base64.decodestring(res['data']))
 
   def testPdfCalcGeneration(self):
-    try:
-      data=open('doc/test.ods').read()
-      res=sp.run_generate('test.ods',enc(data),'calc.pdf')
-      self.assert_(res)
-      open('doc/test.calc.pdf','w').write(base64.decodestring(res[1]))
-    except Fault,e:
-      print e
+    data=open('doc/test.ods').read()
+    res=sp.run_generate('test.ods',enc(data),None,'calc.pdf')
+    self.assert_(res)
+    self.assertEqual(res['mime'],'application/pdf')
+    open('doc/test.calc.pdf','w').write(base64.decodestring(res['data']))
 
   def testPdfImpressGeneration(self):
-    try:
-      data=open('doc/test.odp').read()
-      res=sp.run_generate('test.odp',enc(data),'impr.pdf')
-      self.assert_(res)
-      open('doc/test.impr.pdf','w').write(base64.decodestring(res[1]))
-    except Fault,e:
-      print e
+    data=open('doc/test.odp').read()
+    res=sp.run_generate('test.odp',enc(data),None,'impr.pdf')
+    self.assert_(res)
+    self.assertEqual(res['mime'],'application/pdf')
+    open('doc/test.impr.pdf','w').write(base64.decodestring(res['data']))
 
   def testHtmlWriterGeneration(self):
     self.generateFile('odt','html-writer')
@@ -130,13 +127,14 @@
 
   def generateFile(self,src,ext):
     data=open('doc/test.%s' % src).read()
-    res=sp.run_generate('test.%s' % src,enc(data),ext)
+    res=sp.run_generate('test.%s' % src,enc(data),None,ext)
     self.assert_(res)
-    open('doc/test.%s' % ext,'w').write(base64.decodestring(res[1]))
+    open('doc/test.%s' % ext,'w').write(base64.decodestring(res['data']))
 
 if __name__=='__main__':
   #unittest.main()
   tests=(TestMetaOperations,TestFileOperations)
+  #tests=(TestMetaOperations,)
   for t in tests:
     suite=unittest.makeSuite(t)
     unittest.TextTestRunner(verbosity=2).run(suite)

Modified: erp5/trunk/utils/ooodoc_server/test_worker.py
URL: http://svn.erp5.org/erp5/trunk/utils/ooodoc_server/test_worker.py?rev=9216&r1=9215&r2=9216&view=diff
==============================================================================
--- erp5/trunk/utils/ooodoc_server/test_worker.py (original)
+++ erp5/trunk/utils/ooodoc_server/test_worker.py Tue Aug 15 16:12:04 2006
@@ -64,34 +64,36 @@
 class TestGeneral(unittest.TestCase):
 
   def testBadConvertion(self):
-    self.assertRaises(IllegalMimeType,w.run_convert,'doc/test.html')
+    kw=dict(filename='doc/test.html')
+    self.assertRaises(IllegalMimeType,w.run_convert,kw)
 
   def testBadFile(self):
-    self.assertRaises(NotLoaded,w.run_convert,'doc/test.pdf')
+    kw=dict(filename='doc/test.pdf')
+    self.assertRaises(NotLoaded,w.run_convert,kw)
 
 class TestHandling(unittest.TestCase):
 
   def testConvertion(self):
-    res=w.run_convert(self.name)
-    r=res[0]
-    self.assertEqual(r['Keywords'],u'keywords')
+    kw=dict(filename=self.name)
+    w.run_convert(kw)
+    r=kw['meta']
+    self.assertEqual(r['keywords'],u'keywords')
     self.assertEqual(r['MIMEType'],self.mime)
-    self.assertEqual(r['Subject'],u'subject')
-    self.assertEqual(r['Description'],u'comments')
-    self.assertEqual(r['Title'],u'title')
-    self.assertEqual(res[1][-12:],unicode(os.path.basename(self.convname)))
+    self.assertEqual(kw['mime'],self.mime)
+    self.assertEqual(r['subject'],u'subject')
+    self.assertEqual(r['description'],u'comments')
+    self.assertEqual(r['title'],u'title')
+    self.assertEqual(kw['newfilename'][-12:],unicode(os.path.basename(self.convname)))
 
   def testSetMetadata(self):
-    newmeta={'Title':'New Title','Reference':'abc-def-gh'}
-    print 'newmeta',newmeta
-    res=w.run_setmetadata(self.convname,newmeta)
-    self.assert_(res)
-    got=w.run_getmetadata(self.convname)
-    print 'got',got
-    self.assert_(got['Title']==newmeta['Title'])
-    self.assert_(got['Subject']=='subject')
-    self.assert_(got['Keywords']=='keywords')
-    self.assert_(got['Reference']==u'abc-def-gh')
+    newmeta={'title':'New Title','reference':'abc-def-gh'}
+    kw=dict(filename=self.convname,meta=newmeta)
+    w.run_setmetadata(kw)
+    w.run_getmetadata(kw)
+    self.assert_(kw['meta']['title']==newmeta['title'])
+    self.assert_(kw['meta']['subject']=='subject')
+    self.assert_(kw['meta']['keywords']=='keywords')
+    self.assert_(kw['meta']['reference']==u'abc-def-gh')
 
 class TestDocHandling(TestHandling):
 
@@ -100,16 +102,24 @@
   mime='application/vnd.oasis.opendocument.text'
 
   def testRtfGeneration(self):
-    self.assert_(w.run_generate(self.convname,'rtf'))
+    kw=dict(filename=self.convname,extension='rtf')
+    w.run_generate(kw)
+    self.assert_(kw['newfilename'])
 
   def testDocGeneration(self):
-    self.assert_(w.run_generate(self.convname,'doc'))
+    kw=dict(filename=self.convname,extension='doc')
+    w.run_generate(kw)
+    self.assert_(kw['newfilename'])
 
   def testHtmlGeneration(self):
-    self.assert_(w.run_generate(self.convname,'html-writer'))
+    kw=dict(filename=self.convname,extension='html-writer')
+    w.run_generate(kw)
+    self.assert_(kw['newfilename'])
 
   def testPdfGeneration(self):
-    self.assert_(w.run_generate(self.convname,'pdf'))
+    kw=dict(filename=self.convname,extension='pdf')
+    w.run_generate(kw)
+    self.assert_(kw['newfilename'])
 
 
 class TestXlsHandling(TestHandling):
@@ -119,13 +129,19 @@
   mime='application/vnd.oasis.opendocument.spreadsheet'
 
   def testCsvGeneration(self):
-    self.assert_(w.run_generate(self.convname,'csv'))
+    kw=dict(filename=self.convname,extension='csv')
+    w.run_generate(kw)
+    self.assert_(kw['newfilename'])
 
   def testHtmlGeneration(self):
-    self.assert_(w.run_generate(self.convname,'html-calc'))
+    kw=dict(filename=self.convname,extension='html-calc')
+    w.run_generate(kw)
+    self.assert_(kw['newfilename'])
 
   def testPdfGeneration(self):
-    self.assert_(w.run_generate(self.convname,'calc.pdf'))
+    kw=dict(filename=self.convname,extension='calc.pdf')
+    w.run_generate(kw)
+    self.assert_(kw['newfilename'])
 
 if __name__=='__main__':
   #unittest.main()

Modified: erp5/trunk/utils/ooodoc_server/worker.py
URL: http://svn.erp5.org/erp5/trunk/utils/ooodoc_server/worker.py?rev=9216&r1=9215&r2=9216&view=diff
==============================================================================
--- erp5/trunk/utils/ooodoc_server/worker.py (original)
+++ erp5/trunk/utils/ooodoc_server/worker.py Tue Aug 15 16:12:04 2006
@@ -27,7 +27,7 @@
 #
 ##############################################################################
 
-import os,sys,pdb,time, formatter, htmllib
+import os, sys, pdb, time, string
 import config
 sys.path.append(config.unopath)
 import uno
@@ -41,6 +41,24 @@
 import lib
 from mimemapper import mimemapper
 
+def caseUp(s):
+  '''OOo uses erp5-like naming convention, so we do the same
+  except for MIMEType'''
+  if s=='MIMEType':return s
+  return ''.join(st.capitalize() for st in s.split('_'))
+
+def caseDown(s):
+  try:
+    s=s.encode()
+  except AttributeError:
+    pass
+  if len(s)<=1:return s.lower()
+  if s=='MIMEType':return s
+  r=lambda c: c in string.uppercase and '_'+c or c
+  s=[s[0]]+map(r,s[1:])
+  s=''.join(s).lower()
+  return s
+
 class Worker(object):
 
   '''
@@ -55,8 +73,8 @@
 
   inProps = PropertyValue( "Hidden" , 0 , True, 0 ),
 
-  metafields=('Title','Subject','Keywords','Description','MIMEType')
-  userfields=('Reference','Version','Language')
+  metafields=('title','subject','keywords','description','MIMEType')
+  userfields=('reference','version','language')
   busy=False
 
   def __init__(self,idx,desktop,pool=None):
@@ -77,52 +95,56 @@
     if self.pool is not None:
       self.pool.release(self.idx)
 
-  def convert(self,fname):
-    '''convertion to OOo, returns metadata and OOo file url
-    we return metadata only if converting to OOo (the first conversion), otherwise
-    we don't need them'''
-    self._loadFile(fname)
+  def convert(self,kw):
+    '''convertion to OOo, produces metadata and OOo file url
+    '''
+    self._loadFile(kw['filename'])
     self._convert()
     # if the doc doesn't have title or reference, we use filename for them
     # only on ERP5 object (we don't set them on file)
     # strip filename of #_ prefix
     try:
-      name=os.path.basename(fname)
+      name=os.path.basename(kw['filename'])
       strippedfilename=name[name.index('_')+1:]
     except ValueError:
       strippedfilename=name
-    if not self.metadata.get('Title'):
-      self.metadata['Title']=strippedfilename
-    if not self.metadata.get('Reference'):
-      self.metadata['Reference']=strippedfilename
-    return self.metadata,fileUrlToSystemPath(self.destUrl)
-
-  def generate(self,fname,format):
+    if not self.metadata.get('title'):
+      self.metadata['title']=strippedfilename
+    if not self.metadata.get('reference'):
+      self.metadata['reference']=strippedfilename
+    kw['mime']=self.metadata.get('MIMEType')
+    kw['meta']=self.metadata
+    kw['newfilename']=fileUrlToSystemPath(self.destUrl)
+
+  def generate(self,kw):
     '''generate file in a requested format, return file url
     and a respective mime type'''
-    self._loadFile(fname)
-    self._generate(format)
-    return mimemapper.getMimeFor(format),fileUrlToSystemPath(self.destUrl)
-
-  def setmetadata(self,fname,meta):
+    self._loadFile(kw['filename'])
+    self._generate(kw['extension'])
+    kw['mime']=mimemapper.getMimeFor(kw['extension'])
+    kw['newfilename']=fileUrlToSystemPath(self.destUrl)
+
+  def setmetadata(self,kw):
     '''set metadata on OOo file (fname does not change)'''
-    self._loadFile(fname)
-    self._setMetadata(meta)
+    self._loadFile(kw['filename'])
+    self._setMetadata(kw['meta'])
+    kw['newfilename']=kw['filename']
     self._saveFile()
     return True
 
-  def getmetadatatoolong(self,fname):
+  def getmetadatatoolong(self,kw):
     """
     for debugging - to see if timeout works
     """
-    self._loadFile(fname)
+    self._loadFile(kw['filename'])
+    kw['meta']=self._getMetadata()
+    time.sleep(config.timeout+1)
+    return True
+  
+  def getmetadata(self,kw):
+    self._loadFile(kw['filename'])
     meta=self._getMetadata()
-    time.sleep(config.timeout+1)
-    return meta
-  
-  def getmetadata(self,fname):
-    self._loadFile(fname)
-    meta=self._getMetadata()
+    kw['meta']=meta
     return meta
   
   def _generateFuncs(self):
@@ -195,19 +217,21 @@
 
   def _getMetadata(self):
     '''extract metadata, assign as dictionary
-    no MIME check - we get them also before conversion'''
+    no MIME check - we get them also before conversion
+    we convert names between two naming conventions
+    '''
     self.dinfo=self.doc.getDocumentInfo()
     metadata={}
     for n in self.metafields:
-      v=self.dinfo.getPropertyValue(n)
+      v=self.dinfo.getPropertyValue(caseUp(n))
       if v:
         metadata[n]=v
     for i in range(self.dinfo.getUserFieldCount()):
       n=self.dinfo.getUserFieldName(i)
       v=self.dinfo.getUserFieldValue(i)
-      if n.encode() in self.userfields:
+      if caseDown(n) in self.userfields:
         if v:
-          metadata[n.encode()]=v
+          metadata[caseDown(n)]=v
     return metadata
 
 
@@ -233,20 +257,23 @@
 
   def _setMetadata(self,meta):
     '''set metadata given as a dictionary
-    add new property if does not exist'''
+    add new property if does not exist
+    OOo uses titlecased property names
+    '''
     self._checkMimeType(1)
     self.dinfo=self.doc.getDocumentInfo()
     userfieldcounter=0
     maxcount=self.dinfo.getUserFieldCount()
     for k,v in meta.items():
+      K=caseUp(k)
       if k in self.metafields:
         try:
-          self.dinfo.addProperty(k,0,v)
+          self.dinfo.addProperty(K,0,v)
         except PropertyExistException:
-          self.dinfo.setPropertyValue(k,v)
+          self.dinfo.setPropertyValue(K,v)
       elif k in self.userfields:
         if userfieldcounter<maxcount:
-          self.dinfo.setUserFieldName(userfieldcounter,k)
+          self.dinfo.setUserFieldName(userfieldcounter,K)
           self.dinfo.setUserFieldValue(userfieldcounter,v)
           userfieldcounter+=1
           # we silently ignore if there is too many user fields
@@ -261,8 +288,9 @@
       return []
 
 if __name__=='__main__':
-  w=Worker(None)
-  print w.__dict__
-  w.run_convert('s')
+  print caseDown('Reference')
+  #w=Worker(None)
+  #print w.__dict__
+  #w.run_convert('s')
 #
 # vim: shiftwidth=2




More information about the Erp5-report mailing list