opener-kaf-naf-parser 1.0.0

data/core/site-packages/pre_build/KafNafParser/opinion_data.py

@@ -0,0 +1,200 @@
+#Modified for KAF NAF ok
+
+from lxml import etree
+from lxml.objectify import dump
+from span_data import *
+
+
+
+class Cholder:
+    def __init__(self,node=None):
+        self.type = 'NAF/KAF'
+        if node is None:
+            self.node = etree.Element('opinion_holder')
+        else:
+            self.node = node    
+    
+    def set_span(self,my_span):
+        self.node.append(my_span.get_node())
+
+    def set_comment(self,c):
+        c = c.replace('--','- -')
+        self.node.insert(0,etree.Comment(c) )
+        
+    def get_span(self):
+        span_obj = self.node.find('span')
+        if span_obj is not None:
+            return Cspan(span_obj)
+        return None
+        
+    def __str__(self):
+        return dump(self.node)  
+    
+    def get_node(self):
+        return self.node
+        
+
+class Ctarget:
+    def __init__(self,node=None):
+        self.type = 'NAF/KAF'
+        if node is None:
+            self.node = etree.Element('opinion_target')
+        else:
+            self.node = node    
+    
+    def set_comment(self,c):
+        c = c.replace('--','- -')
+        self.node.insert(0,etree.Comment(c) )
+        
+    def get_comment(self):
+        return self.node_comment
+        
+    def set_span(self,my_span):
+        self.node.append(my_span.get_node())  
+    
+    def get_span(self):
+        span_obj = self.node.find('span')
+        if span_obj is not None:
+            return Cspan(span_obj)
+        return None
+    
+    def __str__(self):
+        return dump(self.node)  
+
+    def get_node(self):
+        return self.node
+        
+        
+class Cexpression:
+    def __init__(self,node=None):
+        self.type = 'NAF/KAF'
+        if node is None:
+            self.node = etree.Element('opinion_expression')
+        else:
+            self.node = node   
+
+    def set_comment(self,c):
+        c = c.replace('--','- -')
+        self.node.insert(0,etree.Comment(c)) 
+    
+    def set_polarity(self,pol):
+        self.node.set('polarity',pol)
+        
+    def get_polarity(self):
+        return self.node.get('polarity')
+        
+    def set_strength(self,st):
+        self.node.set('strength',st)
+        
+    def get_strength(self):
+        return self.node.get('strength')
+        
+    def set_span(self,my_span):
+        self.node.append(my_span.get_node())
+        
+    def get_span(self):
+        span_obj = self.node.find('span')
+        if span_obj is not None:
+            return Cspan(span_obj)
+        return None
+
+    def __str__(self):
+        return dump(self.node)  
+    
+    def get_node(self):
+        return self.node
+
+class Copinion:
+    def __init__(self,node=None,type='NAF'):
+        self.type = type
+        if node is None:
+            self.node = etree.Element('opinion')
+        else:
+            self.node = node  
+    
+    def set_id(self,my_id):
+        if self.type == 'NAF':
+            self.node.set('id',my_id)
+        elif self.type == 'KAF':
+            self.node.set('oid',my_id)
+            
+    def get_id(self):
+        if self.type == 'NAF':
+            self.node.het('id')
+        elif self.type == 'KAF':
+            self.node.get('oid')        
+        
+    def set_holder(self,hol):
+        self.node.append(hol.get_node())
+        
+    def get_holder(self):
+        node_hol = self.node.find('opinion_holder')
+        if node_hol is not None:
+            return Cholder(node_hol)
+        else:
+            return None
+
+    def set_target(self,tar):
+        self.node.append(tar.get_node())
+        
+    def get_target(self):
+        node_target = self.node.find('opinion_target')
+        if node_target is not None:
+            return Ctarget(node_target)
+        else:
+            return None
+        
+    def set_expression(self,exp):
+        self.node.append(exp.get_node())
+
+    def get_expression(self):
+        node_exp = self.node.find('opinion_expression')
+        if node_exp is not None:
+            return Cexpression(node_exp)
+        else:
+            return None
+        
+    def __str__(self):
+        return dump(self.node)  
+    
+    def get_node(self):
+        return self.node
+    
+    
+
+
+
+class Copinions:
+    def __init__(self,node=None,type='NAF'):
+        self.type = type
+        if node is None:
+            self.node = etree.Element('opinions')
+        else:
+            self.node = node
+            
+    def __get_opinion_nodes(self):
+        for node in self.node.findall('opinion'):
+            yield node
+            
+    def get_opinions(self):
+        for node in self.__get_opinion_nodes():
+            yield Copinion(node,self.type)
+            
+    def to_kaf(self):
+        if self.type == 'NAF':
+            for node in self.__get_opinion_nodes():
+                node.set('oid',node.get('id'))
+                del node.attrib['id']
+
+    def to_naf(self):
+        if self.type == 'KAF':
+            for node in self.__get_opinion_nodes():
+                node.set('id',node.get('oid'))
+                del node.attrib['oid']                
+            
+            
+    def add_opinion(self,opi_obj):
+        self.node.append(opi_obj.get_node())
+                         
+    def get_node(self):
+        return self.node

data/core/site-packages/pre_build/KafNafParser/references_data.py

@@ -0,0 +1,15 @@
+# Modified for NAF/KAf
+from span_data import *
+
+class Creferences:
+    def __init__(self,node=None):
+        self.type = 'NAF/KAF'
+        if node is None:
+            self.node = etree.Element('references')
+        else:
+            self.node = node
+            
+    def __iter__(self):
+        for span_node in self.node.findall('span'):
+            yield Cspan(span_node)
+

data/core/site-packages/pre_build/KafNafParser/span_data.py

@@ -0,0 +1,63 @@
+# Modified for KAF/NAF
+
+from lxml import etree
+from lxml.objectify import dump
+
+class Ctarget:
+    def __init__(self,node=None):
+        self.type = 'NAF/KAF'
+        if node is None:
+            self.node = etree.Element('target')
+        else:
+            self.node = node
+            
+    def get_id(self):
+        return self.node.get('id')
+    
+    def set_id(self,this_id):
+        self.node.set('id',this_id)
+        
+    def get_node(self):
+        return self.node
+
+
+class Cspan:
+    def __init__(self,node=None):
+        self.type = 'NAF/KAF'
+        if node is None:
+            self.node = etree.Element('span')
+        else:
+            self.node = node
+             
+    def add_target_id(self,this_id):
+        new_target = Ctarget()
+        new_target.set_id(this_id)
+        self.node.append(new_target.get_node())
+             
+    def create_from_ids(self,list_ids):
+        for this_id in list_ids:
+            new_target = Ctarget()
+            new_target.set_id(this_id)
+            self.node.append(new_target.get_node())
+            
+    def add_target(self,target):
+        self.node.append(target.get_node())
+                   
+
+    def __get_target_nodes(self):
+        for target_node in self.node.findall('target'):
+            yield target_node
+    
+    def __iter__(self):
+        for target_node in self.__get_target_nodes():
+            yield Ctarget(target_node)
+            
+    def get_span_ids(self):
+        return [t_obj.get_id() for t_obj in self]
+    
+    def __str__(self):
+        return dump(self.node)
+    
+    def get_node(self):
+        return self.node
+                                            

data/core/site-packages/pre_build/KafNafParser/term_data.py

@@ -0,0 +1,111 @@
+# included code for NAF/KAF
+
+
+from span_data import *
+from external_references_data import *
+from term_sentiment_data import *
+from lxml import etree
+
+
+class Cterm:
+    def __init__(self,node=None,type='NAF'):
+        self.type = type
+        if node is None:
+            self.node = etree.Element('term')
+        else:
+            self.node = node
+
+            
+    def get_id(self):
+        if self.type == 'NAF':
+            return self.node.get('id')
+        elif self.type == 'KAF':
+            return self.node.get('tid')
+    
+    def get_lemma(self):
+        return self.node.get('lemma')
+    
+    def get_pos(self):
+        return self.node.get('pos')
+    
+    def get_morphofeat(self):
+        return self.node.get('morphofeat')
+    
+    def get_span(self):
+        node_span = self.node.find('span')
+        if node_span is not None:
+            return Cspan(node_span)
+        else:
+            return None
+        
+    def get_sentiment(self):
+        sent_node = self.node.find('sentiment')
+        
+        if sent_node is None:
+            return None
+        else:
+            return Cterm_sentiment(sent_node)
+        
+        
+    def add_external_reference(self,ext_ref):
+        ext_refs_node = self.node.find('externalReferences')
+        if ext_refs_node is None:
+            ext_refs_obj = CexternalReferences()
+            self.node.append(ext_refs_obj.get_node())
+        else:
+            ext_refs_obj = CexternalReferences(ext_refs_node)
+            
+        ext_refs_obj.add_external_reference(ext_ref)
+        
+    def add_term_sentiment(self,term_sentiment):
+        self.node.append(term_sentiment.get_node())
+            
+           
+        
+    
+class Cterms:
+    def __init__(self,node=None,type='NAF'):
+        self.idx = {}
+        self.type = type
+        if node is None:
+            self.node = etree.Element('terms')
+        else:
+            self.node = node
+            for node_term in self.__get_node_terms():
+                self.idx[node_term.get('id')] = node_term    
+    
+    def get_node(self):
+        return self.node
+    
+    def to_kaf(self):
+        if self.type == 'NAF':
+            self.type = 'KAF'
+            for node in self.__get_node_terms():
+                node.set('tid',node.get('id'))
+                del node.attrib['id']
+
+    def to_naf(self):
+        if self.type == 'KAF':
+            self.type = 'NAF'
+            for node in self.__get_node_terms():
+                node.set('id',node.get('tid'))
+                del node.attrib['tid']
+                
+    def __get_node_terms(self):
+        for node_term in self.node.findall('term'):
+            yield node_term
+            
+    def __iter__(self):
+        for node_term in self.__get_node_terms():
+            yield Cterm(node_term,self.type)
+            
+    def get_term(self,term_id):
+        if term_id in self.idx:
+            return Cterm(self.idx[term_id],self.type)
+        else:
+            return None
+           
+    def add_external_reference(self,term_id, external_ref):
+        if term_id in self.idx:
+            term_obj = Cterm(self.idx[term_id],self.type)
+            term_obj.add_external_reference(external_ref)

data/core/site-packages/pre_build/KafNafParser/term_sentiment_data.py

@@ -0,0 +1,42 @@
+# Modified for NAF KAF
+from lxml import etree
+from lxml.objectify import dump
+
+class Cterm_sentiment:
+    def __init__(self,node=None):
+        self.type = 'NAF/KAF'
+        if node is None:
+            self.node = etree.Element('sentiment')
+        else:
+            self.node = node 
+        #self.resource = self.polarity = self.strength = self.subjectivity = self.semantic_type = self.modifier = self.marker = self.product_feature = ''
+        #if node is not None:
+        #    self.resource = node.get('resource','')
+        #    self.polarity = node.get('polarity','')
+        #    self.strength = node.get('strength','')
+        #    self.subjectivity = node.get('subjectivity','')
+        #self.semantic_type = node.get('sentiment_semantic_type','')
+        #    self.modifier = node.get('sentiment modifier','')
+        #    self.marker = node.get('sentiment_marker','')
+        #    self.product_feature = node.get('sentiment product feature','')
+    
+    def set_resource(self,r):
+        self.node.set('resource',r)
+    
+    def get_node(self):
+        return self.node
+    
+    def get_polarity(self):
+        return self.node.get('polarity')
+    
+    def set_polarity(self,p):
+        self.node.set('polarity',p)
+    
+    def get_modifier(self):
+        return self.node.get('sentiment_modifier')
+    
+    def set_modifier(self,sm):
+        self.node.set('sentiment_modifier',sm)
+
+    def __str__(self):
+        return dump(self.node)