[BACK]Return to ECHO_language.py CVS log [TXT] [DIR] Up to [Repository] / ECHO_content

Diff for /ECHO_content/ECHO_language.py between versions 1.4 and 1.7

version 1.4, 2006/09/10 11:03:07 version 1.7, 2006/09/14 14:31:53
Line 1 Line 1
 """Methoden fuer Language Technologies"""  """Methoden fuer Language Technologies"""
   
   from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.ECHO_content.analyseAndTag.analyseAndTag import DonatusFile  from Products.ECHO_content.analyseAndTag.analyseAndTag import DonatusFile
   from OFS.SimpleItem import SimpleItem
   from OFS.Folder import Folder
 import xml.parsers  import xml.parsers
   import os.path
   from Globals import package_home
   
 def donatus(txt2):  class ECHO_language:
         import xmlrpclib          """language methods"""
   
         server = xmlrpclib.ServerProxy("http://archimedes.fas.harvard.edu/cgi-bin/donatus-rpc")  
   
         txt=txt2.encode('utf-8')          def tagLex(self,nr="1",id=None):
         bin=xmlrpclib.Binary(txt)              """gerateword tags"""
   
                   
               df=DonatusFile(txt=self.getPage(_pn=nr,_id=id),baseUri=self.baseUri)
   
         ret=server.donatus.analyze(bin)              return df.convertedXML()
               #return DonatusFile(txt=self.getPage(_pn=nr)).convertedXML()
   
   class Collection(SimpleItem):
                                   
         return ret['morphData'].data           def __init__(self,id):
                """initialise"""
                self.id=id
                self.entries=[]
                
            
            def getEntries(self):
                """get the entries"""
                return self.entries
            
            def deleteEntry(self,nr):
                """delete an entry"""
                del(self.entries[nr])
              
                
            def appendEntry(self,fn,id,type):
                """append an entry"""
                #check if last entry is complete
                createNew=False
                print "Here",fn,id,type
                if len(self.entries)==0: #noch gar kein Eintrag
                    createNew=True
                else:
                    entry=self.entries[-1]
                    if entry.get('master',None) and entry.get('slave',None):
                        createNew=True
                if createNew:
   
                    self.entries.append({})
                    entry=self.entries[-1]
                if type=="master":
                    entry['master']=(fn,id)
                elif type=="slave":
                    entry['slave']=(fn,id)
   
 def donatusVariant2Lemma(morphData):               self.entries[-1]=entry 
         """creates hash variant -> morphdata"""  
         ret={}  
         dom=xml.dom.minidom.parseString(morphData)  
         lemmas=dom.getElementsByTagName('lemma')  
         for lemma in lemmas:  
                 variants=lemma.getElementsByTagName('variant')  
                 for variant in variants:  
                         atr=variant.getAttribute('form')  
                         if ret.has_key(atr):  
                                 ret[atr].append=lemma.getAttribute('form')  
                         else:  
                                 ret[atr]=[lemma.getAttribute('form')]  
   
         return ret  class ECHO_linkCreator(Folder):
        """creator for links"""
   
 class ECHO_language:       meta_type="ECHO_linkCreator"
         """language methods"""  
                   
         def donatusVariant2Lemma(self,nr='1'):  
                 """analyze by donatus"""  
                 return donatusVariant2Lemma(donatus(self.lemmatize(nr)))  
   
                   
         def tagLex(self,nr="1"):  
             """gerateLinks"""  
             txt=self.getPage(_pn=nr)  
                         
             df=DonatusFile(txt=self.getPage(_pn=nr))       def getCollectionEntries(self,collection):
            col=getattr(self,collection,None)
            if not col:
                return []
                         
             return df.wordsToLinks()           return col.getEntries()
             #return DonatusFile(txt=self.getPage(_pn=nr)).convertedXML()  
                   
         def tagLex_old(self,nr="1"):           
                 """generate Links"""       def index_html(self,collection=None):
                 global retLex           """show create links"""
                 global toggle           if not collection:
                return "no collection"
                 toggle=0           
                 retLex=""                
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ECHO_linkCreator_main')).__of__(self)
                 lemmatized=self.lemmatize(nr)[0:]           
                 #print "ho",repr(lemmatized)           col=getattr(self,collection,None)
                 variants=donatusVariant2Lemma(donatus(lemmatized))           if not col:
                                return []
                 def createTag(name,attrs):         
                         global toggle           masterUrl=getattr(col,'masterUrl','')
                                    slaveUrl=getattr(col,'slaveUrl','')
                         if name=="w":           
                                 toggle=1           return pt(collection=collection,masterUrl=masterUrl,slaveUrl=slaveUrl)
                                 return ""       
                         else:       def addEntry(self,collection,fn,id,type,fromurl=None,RESPONSE=None):
                                 tag="<"           """add an entry"""
                                 tag+=name           print "hello"
                                 for attr in attrs.keys():           col=getattr(self, collection,None)
                                         tag+=""" %s="%s" """%(attr,attrs[attr])           if not col:
                                 tag+=">"               self._setObject(collection,Collection(collection))
                         return tag               col=getattr(self, collection)
                                            print "XXXXX2",col  
                 def createData(data):           col.appendEntry(fn,id,type)
                         global toggle           
                         astring="""<a href="http://141.14.236.86/cgi-bin/toc/dict?step=remotetable;word=%s;lang=de" target="_blank">%s</a> """           if fromurl and RESPONSE:
                         if toggle: # tag war ein w               RESPONSE.redirect(fromurl)
                                 toggle=0       def removeEntry(self,collection,nr,RESPONSE=None):
                                 if variants.has_key(data):           """remove an entry"""
                                         return astring%(variants[data][0],data)           col=getattr(self, collection,None)
                                 else:           col.deleteEntry(nr)
                                         return astring%(data,data)           
            if RESPONSE:
                RESPONSE.redirect(self.absolute_url()+"?collection="+collection)
            
        def setUrls(self,collection,masterUrl,slaveUrl,RESPONSE=None):
            """set the urls for the document viewer"""
            col=getattr(self, collection,None)
            setattr(col,'masterUrl',masterUrl)
            setattr(col,'slaveUrl',slaveUrl)
            
            if RESPONSE:
                RESPONSE.redirect(self.absolute_url()+"?collection="+collection)
                                                                   
                                                                                   
            #self.index_html(collection)
   
                 # 3 handler functions  def manage_addECHO_linkCreatorForm(self,RESPONSE=None):
                 def start_element(name, attrs):      """Form for adding"""
                         global retLex      manage_addECHO_linkCreator(self,RESPONSE)
                                                   
                         retLex+=createTag(name,attrs)  def manage_addECHO_linkCreator(self,RESPONSE=None):
                 def end_element(name):      """Add an ECHO_main"""
                         global retLex      id='linkCreator'
                         if not name=="w":      self._setObject(id,ECHO_linkCreator(id))
                                 retLex+="</%s>"%(name.encode('utf-8'))  
                                                   
                                           
                 def char_data(data):      if RESPONSE is not None:
                         global retLex          RESPONSE.redirect('manage_main')      
                         if data:  
                                 try:  
                                         retLex+=createData(data)  
                                 except:  
                                         """no"""  
                                                                                   
                 p = xml.parsers.expat.ParserCreate()  
   
                 p.StartElementHandler = start_element  
                 p.EndElementHandler = end_element  
                 p.CharacterDataHandler = char_data  
                                   
                 p.Parse(lemmatized.encode('utf-8'),1)  
                 #print repr(lemmatized.encode('utf-8'))  
                   
                 return retLex  
                   
                                   
         def lemmatize(self,nr='1',lang="de"):  
                 """lemmatize"""  
                 global ret  
                 ret=""  
                                   
                 def createTag(name,attrs):  
                         tag="<"  
                         tag+=name  
                         for attr in attrs.keys():  
                                 tag+=""" %s="%s" """%(attr,attrs[attr])  
                         tag+=">"  
                         return tag  
                                                                   
                 def insertW(str):  
                     splitted=str.split()  
                     wordlist=["<w>%s</w>"%split for split in splitted]  
                     return "\n".join(wordlist)  
   
                 # 3 handler functions  
                 def start_element(name, attrs):  
                         global ret  
                         ret+=createTag(name,attrs)  
                 def end_element(name):  
                         global ret  
                         ret+="</%s>"%(name.encode('utf-8'))  
                                           
                 def char_data(data):  
                         global ret  
                         ret+=insertW(data)  
   
                 p = xml.parsers.expat.ParserCreate()  
   
                 p.StartElementHandler = start_element  
                 p.EndElementHandler = end_element  
                 p.CharacterDataHandler = char_data  
   
                 p.Parse(self.getPage(nr), 1)  
                 txt="""<wtag locator="xxx">  
                 <section lang="%s"><s>%s</s></section>  
                 </wtag>"""  
                 ret=txt%(lang,ret)  
                                   
                 return ret  
Removed from v.1.4  
changed lines
  Added in v.1.7

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