[BACK]Return to cdliSplitter.py CVS log [TXT] [DIR] Up to [Repository] / cdli

Diff for /cdli/cdliSplitter.py between versions 1.7 and 1.7.2.3

version 1.7, 2007/08/31 14:22:52 version 1.7.2.3, 2007/10/19 16:30:58
Line 1 Line 1
 """  """
 Author splitter  CDLI word and grapheme splitter
 """  """
   
 import Zope2  
 import transaction  
   
 from Products.ZCTextIndex.ISplitter import ISplitter  
 from Products.ZCTextIndex.PipelineFactory import element_factory  from Products.ZCTextIndex.PipelineFactory import element_factory
   
 import re  import re
 from types import StringType  
 import logging  import logging
 try:  
     import PyLucene  
 except:  
     print "no Lucene support"  
   
 def getSupportedEncoding(encodings):  def getSupportedEncoding(encodings):
     for encoding in encodings:      for encoding in encodings:
Line 32  def getSupportedEncoding(encodings): Line 23  def getSupportedEncoding(encodings):
 """  """
 ignoreLines=['$','@','#','&','>']  ignoreLines=['$','@','#','&','>']
 separators=['']  separators=['']
 komma_exception="([^sStThH])," # komma relevant for graphemes will not be deleted  # kommas relevant for graphemes will not be deleted
 deleteGraphems="\{|\}|<|>|\(|\)|-|_|\#|,|\||\]|\[|\!|\?" # for graphems  komma_exception="([^sStThH])," 
 deleteWords="<|>|\(|\)|_|\#|,|\||\]|\[|\!|\?"# for words  # grapheme boundaries
   graphemeBounds="\{|\}|<|>|\(|\)|-|_|\#|,|\||\]|\[|\!|\?"
 class IndexLine(object):  # for words 
     """index a line with lucene"""  wordBounds="<|>|\(|\)|_|\#|,|\||\]|\[|\!|\?"
   
     def __init__(self, storeDir, analyzer,name,line,content):  
         logging.error("i am here %s %s %s %s %s"%((storeDir, analyzer,name,line,content)))  
         if not os.path.exists(storeDir):  
             os.mkdir(storeDir)  
         store = PyLucene.FSDirectory.getDirectory(storeDir, True)  
         writer = PyLucene.IndexWriter(store, analyzer, True)  
         writer.setMaxFieldLength(1048576)  
         self.indexDocs(writer,name,line,content)    
         writer.optimize()  
         writer.close()  
         
     def indexDocs(self, writer,name,line,content):  
          
         doc = PyLucene.Document()  
         doc.add(PyLucene.Field("name", pn,  
                                PyLucene.Field.Store.YES,  
                                PyLucene.Field.Index.UN_TOKENIZED))  
         
         doc.add(PyLucene.Field("line", str(i),  
                                PyLucene.Field.Store.YES,  
                                PyLucene.Field.Index.UN_TOKENIZED))  
         
                   
         doc.add(PyLucene.Field("contents", line,  
                                PyLucene.Field.Store.YES,  
                                PyLucene.Field.Index.TOKENIZED))  
                   
         writer.addDocument(doc)  
                         
 class cdliSplitter:  class cdliSplitter:
     """basis class for splitter,       """base class for splitter. 
     der Unterschied zwischen Word und Graphemesplitter       the difference between word and grapheme splitter 
     ist lediglich die unterschiedliche Auschliengsliste"""      is the word boundary list."""
           
     default_encoding = "utf-8"      default_encoding = "utf-8"
     delete=deleteGraphems      bounds=graphemeBounds
     indexName="cdliSplitter"      indexName="cdliSplitter"
           
           
     def process(self, lst):      def process(self, lst):
           """gets a list of strings and returns a list of words"""
           
           logging.debug("cdliSplitter") 
         result = []          result = []
         pNum=None          pNum=None
         lineNum=None          lineNum=None
           
         for t in lst:          for t in lst:
                     # normalise line breaks
          t.replace("\r","\n")           t.replace("\r","\n")
               # split lines
          for s in t.split("\n"):           for s in t.split("\n"):
                         if isinstance(s, str): 
             if type(s) is StringType: # not unicode                      # not unicode
                 s = unicode(s, self.default_encoding, 'replace')                  s = unicode(s, self.default_encoding, 'replace')
             
             if (s!="") and (s[0]=="&"): # store pNum                  if (s!=''):
                       if s[0]=='&': 
                           # store pNum
                 pNum=s[1:8]                  pNum=s[1:8]
                 logging.debug("storing: %s"%pNum)                              logging.debug("%s processing: %s"%(self.indexName,pNum))
             elif (s!="") and (not (s[0] in ignoreLines)):  
                 splitted=s.split(".")  
                                 
                 if len(splitted)==1: #kein punkt                      elif not (s[0] in ignoreLines):
                     txt=splitted[0]                          # regular line
                           lineparts=s.split(".")
                           if len(lineparts)==1: 
                               # no line number
                               txt=s
                 else:                  else:
                     txt=splitted[1]                              #store line number
                     lineNum=splitted[0] #store line number                              txt=lineparts[1]
                                               lineNum=lineparts[0] 
                 analyse=txt                                    
                 analyse=re.sub(komma_exception,r"\1",analyse) # delete kommata except kommata relevant in graphems                          # delete kommata except kommata relevant for graphemes
                 analyse=re.sub(self.delete,' ',analyse) # deletions                          txt = re.sub(komma_exception,r"\1",txt)
                                           # replace word boundaries by spaces
                 if self.indexName=="luceneSplitter":                          txt = re.sub(self.bounds,' ',txt)
                     if pNum:                          # split words
                         analyser=PyLucene.StandardAnalyzer()                          words = txt.split(" ")
                         logging.error("calling lucene")                          for w in words:
                                                       w=w.strip()
                         IndexLine("/tmp/index",analyser,pNum,lineNum,analyse)  
                 else:  
                     splitted = analyse.split(" ")  
                      
                      
                     for w in splitted:  
                         w=w.lstrip().rstrip()  
       
                         if not (w==''):                          if not (w==''):
                             if pNum: #only whe pnum is found (first call of the splitter, is always called twice in the pipeline                                  result.append(w)
       
                                 Zope2.app().cdliRoot.storeInLineIndex(self.indexName,w.lstrip().strip(),(pNum,lineNum))  
                                 transaction.get().commit()  
           
                             result.append(w.lstrip().rstrip())  
         return result          return result
   
   
 class graphemeSplitter(cdliSplitter):  class graphemeSplitter(cdliSplitter):
     delete=deleteGraphems      bounds=graphemeBounds
     indexName="graphemeSplitter"      indexName="graphemeSplitter"
           
 class wordSplitter(cdliSplitter):  class wordSplitter(cdliSplitter):
     delete=deleteWords      bounds=wordBounds
     indexName="wordSplitter"      indexName="wordSplitter"
   
 class luceneSplitter(cdliSplitter):  
     delete=deleteWords  
     indexName="luceneSplitter"  
       
         
 try:  try:
     element_factory.registerFactory('Word Splitter',      element_factory.registerFactory('Word Splitter',
           'CDLI grapheme splitter', graphemeSplitter)            'CDLI grapheme splitter', graphemeSplitter)
Line 157  except: Line 111  except:
     # in case the splitter is already registered, ValueError is raised      # in case the splitter is already registered, ValueError is raised
     pass      pass
   
 try:  
     element_factory.registerFactory('Word Splitter',  
           'CDLI lucene splitter', luceneSplitter)  
 except:  
     # in case the splitter is already registered, ValueError is raised  
     pass  
 if __name__ == '__main__':  
    a = 'abc def我们的很 好。'  
    u = unicode(a, 'gbk')  
    s = authorSplitter()  
    print s.process([u])  
    print s.process([u], 1)  
Removed from v.1.7  
changed lines
  Added in v.1.7.2.3

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>