opener-constituent-parser-de 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d5a9ae0201da32865ead9a1fe9524712c148204a
+  data.tar.gz: 609f1d0465fab2a08278cebdc484949d0fe98e72
+SHA512:
+  metadata.gz: b1b526f3a0b0787591003013e54065d172aa82e32fb4b333537fdf2e2b6724926fc6e58e45180a53df36e03340f0f249a160918621b62d22896f6260f3f501f6
+  data.tar.gz: 126d01c13291d08eadc89203f9a8e3471d46e35360b004c1153d7a17fe1808684be3f65a731e47e19ccc89ff825a3fbaae34ea643e608c0cdb09345de1016007

data/README.md

@@ -0,0 +1,41 @@
+[![Build Status](https://drone.io/github.com/opener-project/constituent-parser-de/status.png)](https://drone.io/github.com/opener-project/constituent-parser-de/latest)
+
+VU-parser-DE_kernel
+===================
+
+Introduction
+------------
+
+This is a parser for German text using the Stanford parser (http://nlp.stanford.edu/software/lex-parser.shtml). The input for this module has to be a valid
+KAF file with at least the text layer. The output will be the constituent trees in pennTreebank format for each of the sentences in the input KAF.
+The tokenization and sentence splitting is taken from the input KAF file, so if your input file has a wrong tokenization/splitting, the output could
+contain errors. The number of output constituent trees will be exactly the same as the number of sentences in your input KAF
+
+Requirements
+-----------
+* VUKafParserPy: parser in python for KAF files (https://github.com/opener-project/VU-kaf-parser)
+* lxml: library for processing xml in python
+* Stanford parser: http://nlp.stanford.edu/software/lex-parser.shtml
+
+Installation
+-----------
+Clone the repository to your local machine and set the varible STANFORD_HOME in the file core/stanford_parser_de.py
+to point to your local folder of the Stanford parser.
+
+How to run the module with Python
+---------------------------------
+
+You can run this module from the command line using Python. The main script is core/stanford_parser_de.py. This script reads the KAF from the standard input
+and writes the output to the standard output, generating some log information in the standard error output. To process one file just run:
+````shell
+cat input.kaf | core/stanford_parser_de.py > input.tree
+````
+
+This will read the KAF file in "input.kaf" and will store the constituent trees in "input.tree".
+
+
+Contact
+------
+* Ruben Izquierdo
+* Vrije University of Amsterdam
+* ruben.izquierdobevia@vu.nl

data/bin/constituent-parser-de

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/opener/constituent_parsers/de'
+
+kernel = Opener::ConstituentParsers::DE.new(:args => ARGV)
+input  = STDIN.tty? ? nil : STDIN.read
+
+kernel.run!(input)

data/core/convert_penn_to_kaf.py

@@ -0,0 +1,127 @@
+from lxml import etree
+from tree import Tree
+
+
+
+
+
+list_t = []
+list_nt = []
+list_edge = []
+cnt_t = cnt_nt = cnt_edge = 0
+
+##This function generates a "tree" xml element as defined in KAF from a string containing
+##the penntreebank format and a list of term ids to do the linking
+'''           
+s = '(S (NP (DET The) (NN dog)) (VP (V ate) (NP (DET the) (NN cat))) (. .))'
+ids = ['t0 t1','t2','t3','t4','t5','t6']
+tree_node = create_constituency_layer(s, ids)
+e = etree.ElementTree(element=tree_node)
+e.write(sys.stdout,pretty_print=True)
+'''
+def convert_penn_to_kaf(tree_str,term_ids,logging,lemma_for_termid,off_t,off_nt,off_edge):
+    global list_t, list_nt,list_edge,cnt_t,cnt_nt,cnt_edge
+    list_t = []
+    list_nt = []
+    list_edge = []
+    cnt_t = off_t
+    cnt_nt = off_nt
+    cnt_edge = off_edge
+    
+    this_tree = Tree(tree_str)
+    logging.debug('\n'+str(this_tree))
+
+   
+    for num, token in enumerate(this_tree.leaves()):
+        position = this_tree.leaf_treeposition(num)
+        token_id = term_ids[num]
+        this_tree[position] = token_id
+        logging.debug('Matching '+token+' with term id='+token_id+' which according to KAF lemma='+str(lemma_for_termid.get(token_id).encode('utf-8')))
+
+    
+    ##Creat the ROOT
+    create_extra_root = False
+    nt_id = None
+    if create_extra_root:
+        nt_id = 'nter'+str(cnt_nt)
+        cnt_nt +=1
+        list_nt.append((nt_id,'ROOT'))
+    
+    visit_node(this_tree, nt_id)
+ 
+    root = etree.Element('tree')
+    nonter_heads = set()
+    #Nonter
+    labels_for_nt = {}
+    for nt_id, label in list_nt:
+        ##Checking the head
+        if len(label)>=2 and label[-1]=='H' and label[-2]=='=':
+            nonter_heads.add(nt_id)
+            label = label[:-2]
+        ele = etree.Element('nt', attrib={'id':nt_id,'label':label})
+        labels_for_nt[nt_id] = label
+        root.append(ele)
+    
+    ## Terminals
+    lemma_for_ter = {}
+    for ter_id, span_ids in list_t:
+        ele = etree.Element('t',attrib={'id':ter_id})
+        span = etree.Element('span')
+        ele.append(span)
+        for termid in span_ids.split(' '):
+            target = etree.Element('target',attrib={'id':termid})
+            span.append(target)
+        lemma_for_ter[ter_id] = lemma_for_termid.get(termid,'unknown')
+        root.append(ele)
+        
+    ##Edges
+    #for edge_id,node_to,node_from in list_edge:
+    for edge_id, node_from, node_to in list_edge:
+        ele = etree.Element('edge',attrib={'id':edge_id,'from':node_from,'to':node_to})
+        
+        ## For the comment
+        ##Only non-ter
+        label_to = labels_for_nt.get(node_to)
+        
+        ##Could be ter or nonter
+        label_from = labels_for_nt.get(node_from)
+        if label_from is None:
+            label_from = lemma_for_ter.get(node_from,'kk')
+                                        
+        comment = '  '+(edge_id)+'  '+(label_to)+' <- '+(label_from)+' '
+        
+        if node_from in nonter_heads:
+            ele.set('head','yes')
+        root.append(etree.Comment(comment))
+        root.append(ele)
+          
+    return root,cnt_t,cnt_nt,cnt_edge
+
+    
+def visit_node(node,id_parent=None):
+    global list_t, list_nt,list_edge,cnt_t,cnt_nt,cnt_edge
+    if isinstance(node,str): #is a terminal
+        ##Create the terminal
+        t_id = 'ter'+str(cnt_t)
+        cnt_t += 1
+        list_t.append((t_id,str(node)))
+        
+        ##Create the edge with the parent
+        edge_id = 'tre'+str(cnt_edge)
+        cnt_edge +=1
+        list_edge.append((edge_id,t_id,id_parent))
+    else:  #Is a non terminal
+        ##Create the nonterminal
+        nt_id = 'nter'+str(cnt_nt)
+        cnt_nt += 1 
+        list_nt.append((nt_id,node.node))
+        
+        ##Create the linking with the parent
+        if id_parent is not None:
+            edge_id = 'tre'+str(cnt_edge)
+            cnt_edge += 1
+            list_edge.append((edge_id,nt_id,id_parent))
+        
+        ##Call to the child
+        for child in node:
+            visit_node(child,nt_id)

data/core/site-packages/pre_build/VUKafParserPy-1.0-py2.7.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: VUKafParserPy
+Version: 1.0
+Summary: Library in python to parse kaf files
+Home-page: UNKNOWN
+Author: Ruben Izquierdo
+Author-email: r.izquierdobevia@vu.nl
+License: UNKNOWN
+Description: UNKNOWN
+Platform: UNKNOWN

data/core/site-packages/pre_build/VUKafParserPy-1.0-py2.7.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+VUKafParserPy/KafDataObjectsMod.py
+VUKafParserPy/KafParserMod.py
+VUKafParserPy/__init__.py
+VUKafParserPy.egg-info/PKG-INFO
+VUKafParserPy.egg-info/SOURCES.txt
+VUKafParserPy.egg-info/dependency_links.txt
+VUKafParserPy.egg-info/top_level.txt

data/core/site-packages/pre_build/VUKafParserPy-1.0-py2.7.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

data/core/site-packages/pre_build/VUKafParserPy-1.0-py2.7.egg-info/installed-files.txt

@@ -0,0 +1,11 @@
+../VUKafParserPy/KafParserMod.py
+../VUKafParserPy/__init__.py
+../VUKafParserPy/KafDataObjectsMod.py
+../VUKafParserPy/KafParserMod.pyc
+../VUKafParserPy/__init__.pyc
+../VUKafParserPy/KafDataObjectsMod.pyc
+./
+top_level.txt
+SOURCES.txt
+PKG-INFO
+dependency_links.txt

data/core/site-packages/pre_build/VUKafParserPy-1.0-py2.7.egg-info/top_level.txt

@@ -0,0 +1 @@
+VUKafParserPy

data/core/site-packages/pre_build/VUKafParserPy/KafDataObjectsMod.py

@@ -0,0 +1,161 @@
+class KafTermSentiment:
+  def __init__(self):
+    self.resource=None
+    self.polarity=None
+    self.strength=None
+    self.subjectivity=None
+    
+  def simpleInit(self,r,p,st,su,sm=None):
+    self.resource=r
+    self.polarity=p
+    self.strength=st
+    self.subjectivity=su
+    self.sentiment_modifier = sm
+    
+  def getPolarity(self):
+    return self.polarity
+  
+  def getSentimentModifier(self):
+    return self.sentiment_modifier
+    
+    
+class KafToken:
+  def __init__(self,wid, value, sent=None, para=None):
+    self.token_id = wid
+    self.value = value
+    self.sent = sent
+    self.para = para
+  
+
+class KafOpinionExpression:
+  def __init__(self,polarity,strength,targets):
+    self.polarity = polarity
+    self.strength = strength
+    self.targets = targets
+    
+  def __str__(self):
+    return 'Op_exp==> pol:'+self.polarity+' Str:'+self.strength+' ids:'+'-'.join(self.targets)
+    
+class KafOpinion:
+  def __init__(self,id,holders, targets, opi_exp):
+    self.id = id
+    self.holders = holders
+    self.targets = targets
+    self.opi_exp = opi_exp
+    
+  def __str__(self):
+    c='Opinion id'+self.id+'\n'
+    c+='  Holders: '+'-'.join(self.holders)+'\n'
+    c+='  Targets: '+'-'.join(self.targets)+'\n'
+    c+=str(self.opi_exp)
+    return c
+    
+    
+
+class KafSingleProperty:
+  def __init__(self,id,type,targets):
+    self.id = id
+    self.type = type
+    self.targets = targets
+    
+    
+  def get_id(self):
+    return self.id
+    
+  def get_type(self):
+    return self.type
+  
+  def get_span(self):
+    return self.targets
+  
+  def __str__(self):
+    return 'Id: '+self.id+' Type: '+self.type+' ids:'+' '.join(self.targets)
+
+
+class KafSingleEntity:
+  def __init__(self,id,type,targets):
+    self.id = id
+    self.type = type
+    self.targets = targets
+    
+  def get_id(self):
+    return self.id
+    
+  def get_type(self):
+    return self.type
+  
+  def get_span(self):
+    return self.targets
+  
+  def __str__(self):
+    return 'Id: '+self.id+' Type: '+self.type+' ids:'+' '.join(self.targets)
+
+class KafTerm:
+  def __init__(self):
+    self.tid = None
+    self.lemma = None
+    self.pos = None
+    self.sentiment = None
+    self.list_span_id = []
+    
+  def set_list_span_id(self, L):
+    self.list_span_id = L
+    
+  def get_list_span(self):
+    return self.list_span_id
+    
+  def get_polarity(self):
+    if self.sentiment != None:
+      return self.sentiment.getPolarity()
+    else:
+      return None
+      
+  def get_sentiment_modifier(self):
+    if self.sentiment != None:
+      return self.sentiment.getSentimentModifier()
+    else:
+      return None
+    
+    
+  def setSentiment(self,my_sent):
+    self.sentiment = my_sent
+    
+  def getSentiment(self):
+    return self.sentiment
+    
+  def getLemma(self): 
+      return self.lemma
+    
+  def setLemma(self,lemma):
+      self.lemma = lemma
+    
+  def getPos(self):
+      return self.pos
+    
+  def setPos(self,pos):
+      self.pos = pos
+      
+  def getId(self):
+      return self.tid
+      
+  def setId(self,id):
+      self.tid = id
+
+  def getShortPos(self):
+    if self.pos==None:
+      return None
+    auxpos=self.pos.lower()[0]
+    if auxpos == 'g': auxpos='a'
+    elif auxpos == 'a': auxpos='r'
+    return auxpos
+    
+  def __str__(self):
+    if self.tid and self.lemma and self.pos:
+        return self.tid+'\n\t'+self.lemma.encode('utf-8')+'\n\t'+self.pos
+    else:
+        return 'None'
+      
+    
+    
+    
+    

data/core/site-packages/pre_build/VUKafParserPy/KafParserMod.py

@@ -0,0 +1,326 @@
+########################################################################
+# 14 Jan 2013: added function add_attrs_to_layer
+########################################################################
+
+###################
+# List of changes #
+###################
+# 14 Jan 2013: added function add_attrs_to_layer
+# 27 Feb 2013: added code for comply with DTD
+# 18 Jun 2013: getSingleProperties adapted to the structure KAF/features/properties/property/references/span/target
+# 18 Jun 2013: funcion add_property created for adding the properties to the KAF
+from lxml import etree
+from KafDataObjectsMod import *
+import time
+
+class KafParser:
+  def __init__(self,filename=None):
+	self.tree=None
+	self.__pathForToken={}
+	
+	if filename:
+		self.tree = etree.parse(filename,etree.XMLParser(remove_blank_text=True))
+		## Do the text tokenization
+		self.__textTokenization()
+	else:
+		root = etree.Element('KAF')
+		root.set('version','v1.opener')
+		root.set('{http://www.w3.org/XML/1998/namespace}lang','en')
+		self.tree = etree.ElementTree(element=root)
+		
+  def __textTokenization(self):
+	for wf in self.tree.findall('text/wf'):
+	  wid = wf.get('wid')
+	  self.__pathForToken[wid] = self.tree.getpath(wf)
+	 
+  
+  def getToken(self,tid):
+	path = self.__pathForToken[tid]
+	return self.tree.xpath(self.__pathForToken[tid])[0]
+
+  
+  def getLanguage(self):
+	  lang = self.tree.getroot().get('{http://www.w3.org/XML/1998/namespace}lang','nl')
+	  return lang
+	  
+  def getTokens(self):
+	for element in self.tree.findall('text/wf'):
+	  w_id = element.get('wid')
+	  s_id = element.get('sent','0')
+	  word = element.text
+	  yield (word, s_id, w_id)
+	
+  def getTerms(self):
+	 if self.tree:
+	   for element in self.tree.findall('terms/term'):
+		   kafTermObj = KafTerm()
+		   kafTermObj.setId(element.get('tid'))
+		   kafTermObj.setLemma(element.get('lemma'))
+		   kafTermObj.setPos(element.get('pos'))
+		   
+		   ## Parsing sentiment
+		   sentiment = element.find('sentiment')
+		   if sentiment is not None:
+			 resource = sentiment.get('resource','')
+			 polarity = sentiment.get('polarity',None)
+			 strength = sentiment.get('strength','')
+			 subjectivity = sentiment.get('subjectivity','')
+			 sentiment_modifier = sentiment.get('sentiment_modifier')
+			 
+			 my_sent = KafTermSentiment()
+			 my_sent.simpleInit(resource,polarity,strength,subjectivity,sentiment_modifier)
+			 kafTermObj.setSentiment(my_sent)
+		  
+		   ## Parsing the span
+		   span = element.find('span')
+		   if span is not None:
+			list_ids = [target.get('id') for target in span.findall('target')]
+			kafTermObj.set_list_span_id(list_ids)
+		
+			 
+		   yield kafTermObj
+	 else:
+	   return
+	  
+	  
+  def getSentimentTriples(self):
+	data = []
+	if self.tree:
+	  for term_element in self.tree.findall('terms/term'):
+		lemma = term_element.get('lemma')
+		polarity = None
+		sentiment_modifier = None
+		
+		sentiment_element = term_element.find('sentiment')
+		if sentiment_element is not None:
+			polarity = sentiment_element.get('polarity',None)
+			sentiment_modifier = sentiment_element.get('sentiment_modifier')
+		data.append( (lemma,polarity,sentiment_modifier))
+	return data
+	  
+   
+	  
+  def addPolarityToTerm(self,termid,my_sentiment_attribs,polarity_pos=None):
+	if self.tree:
+	  for element in self.tree.find('terms'):
+		if element.get('tid','')==termid:
+		  
+		  #In case there is no pos info, we use the polarityPos
+		  if not element.get('pos') and polarity_pos is not None:
+			element.set('pos',polarity_pos)
+		  sentEle = etree.Element('sentiment',attrib=my_sentiment_attribs)
+		  element.append(sentEle)  
+	  
+  def saveToFile(self,filename,myencoding='UTF-8'):
+	if self.tree:
+	  self.tree.write(filename,encoding=myencoding,pretty_print=True,xml_declaration=True)
+	  
+  
+  def addLinguisticProcessor(self,name,version, layer, time_stamp=True):
+	aux = self.tree.findall('kafHeader')
+	if len(aux)!=0:
+	  kaf_header = aux[0]
+	else:
+	  kaf_header = etree.Element('kafHeader')
+	  self.tree.getroot().insert(0,kaf_header)
+
+	## Check if there is already element for the layer
+	my_lp_ele = None
+	
+	for element in kaf_header.findall('linguisticProcessors'):
+	  if element.get('layer','')==layer:
+		my_lp_ele = element
+		break
+	  
+	if time_stamp:  
+	  my_time = time.strftime('%Y-%m-%dT%H:%M:%S%Z')
+	else:
+	  my_time = '*'
+	  
+	my_lp = etree.Element('lp')
+	my_lp.set('timestamp',my_time)
+	my_lp.set('version',version)
+	my_lp.set('name',name)
+
+	if my_lp_ele is not None: #Already an element for linguisticProcessor with the layer
+	  my_lp_ele.append(my_lp)
+	else:
+	  # Create a new element for the LP layer
+	  my_lp_ele = etree.Element('linguisticProcessor')
+	  my_lp_ele.set('layer',layer)
+	  my_lp_ele.append(my_lp)
+	  #my_lp_ele.tail=my_lp_ele.text='\n'
+	  ## Should be inserted after the last linguisticProcessor element (stored in variable element)
+	  idx = kaf_header.index(element)
+	  kaf_header.insert(idx+1,my_lp_ele)
+		
+	  
+  def addLayer(self,type,element,first_char_id=None):
+	if first_char_id is None:
+		first_char_id = type[0]
+		
+	## Check if there is already layer for the type
+	layer_element = self.tree.find(type)
+	
+	if layer_element is None:
+	  layer_element = etree.Element(type)
+	  self.tree.getroot().append(layer_element)
+	  ## The id is going to be the first one
+	  new_id = first_char_id+'1'
+	else:
+	  ## We need to know how many elements there are in the layer
+	  current_n = len(layer_element.getchildren())
+	  new_id = first_char_id+''+str(current_n+1)
+	  
+	  
+	## In this point layer_element points to the correct element, existing or created
+	
+	element.set(first_char_id+'id',new_id)
+	layer_element.append(element)
+	return new_id
+	
+  def addElementToLayer(self,layer, element,first_char_id=None):
+	return self.addLayer(layer,element,first_char_id)
+
+  def add_attrs_to_layer(self,layer,attrs):
+	layer_element = self.tree.find(layer)
+	if layer_element is not None:
+	  for att, val in attrs.items():
+		layer_element.set(att,val)
+		
+
+  def addAttributeToElement(self,path,str_id, id, attribute, value,sub_path=None):
+	  for element in self.tree.findall(path):
+		if id is not None and element.get(str_id,None) == id:
+		  if sub_path is not None:
+			elements = element.findall(sub_path)
+			if len(elements)!=0: element = elements[0]
+		  element.set(attribute,value)
+		  return
+
+  
+  ## This works with the original definition of the property layer
+  ## KAF -> properties -> property* -> span* -> target*
+  def getSingleProperties_old(self):
+	  for element in self.tree.findall('properties/property'):
+		  my_id = element.get('pid')
+		  my_type = element.get('type')
+		  ref = element.find('references')
+		  if ref is not None:
+			element = ref
+		  for span_element in element.findall('span'):
+			  target_ids = [target_element.get('id') for target_element in span_element.findall('target')]
+			  my_prop = KafSingleProperty(my_id,my_type,target_ids)
+			  yield my_prop
+			   
+  ## 18-June-2013
+  def getSingleProperties(self):
+	  for property in self.tree.findall('features/properties/property'):
+		  my_id = property.get('pid')
+		  if my_id is None:
+			  my_id = property.get('fpid')
+		  my_type = property.get('lemma')
+		  for span_element in property.findall('references/span'):
+			  target_ids = [target_element.get('id') for target_element in span_element.findall('target')]
+			  my_prop = KafSingleProperty(my_id,my_type,target_ids)
+			  yield my_prop
+
+  # This function adds a new property of the type given with the list of ids given
+  # my_type -> 'sleeping comfort'	list_ids = ['id1','id2']
+  # It creates the features/properties layers in case 
+  # Agglomerates all the properties for the same TYPE under the same property element
+  # It calculates automatically the number for the identifier depending on the number
+  # of properties existing
+  def add_property(self,my_type,list_ids):
+      
+      #Looking for feature layer or creating it
+      feature_layer = self.tree.find('features')
+      if feature_layer is None:
+          feature_layer = etree.Element('features')
+          self.tree.getroot().append(feature_layer)
+          
+      #Looking for properties layer
+      properties_layer = feature_layer.find('properties')
+      if properties_layer is None:
+          properties_layer = etree.Element('properties')
+          feature_layer.append(properties_layer)
+          
+      num_props = 0
+      property_layer = None
+      for property in properties_layer.findall('property'):
+          num_props += 1
+          prop_type = property.get('lemma')
+          if prop_type == my_type:
+              property_layer = property
+              break
+          
+      if property_layer is None:  # There is no any property for that type, let's create one
+          property_layer = etree.Element('property')
+          property_layer.set('pid','p'+str(num_props+1))
+          property_layer.set('lemma',my_type)    
+          properties_layer.append(property_layer)
+          
+          
+      references = property_layer.find('references')
+      if references is None:
+          references = etree.Element('references')
+          property_layer.append(references)
+      ## Create the new span
+      span = etree.Element('span')
+      references.append(span)
+      for my_id in list_ids:
+           span.append(etree.Element('target',attrib={'id':my_id}))
+       
+   
+			  
+  
+  def getSingleEntities(self):
+	  for element in self.tree.findall('entities/entity'):
+		  my_id = element.get('eid')
+		  my_type = element.get('type')
+		  my_path_to_span = None
+		  ref = element.find('references')
+		  if ref is not None:
+                      my_path_to_span = 'references/span'
+                  else:
+                      my_path_to_span = 'span'
+
+		  for span_element in element.findall(my_path_to_span):
+			  target_ids = [target_element.get('id') for target_element in span_element.findall('target')]
+			  my_prop = KafSingleEntity(my_id,my_type,target_ids)
+			  yield my_prop
+
+
+  def getOpinions(self):
+	for element in self.tree.findall('opinions/opinion'):
+	  my_id = element.get('oid')
+	  
+	  tar_ids_hol = []
+	  tar_ids_tar = []
+	  polarity = strenght = ''
+	  tar_ids_exp = []
+	  
+	  #Holder
+	  opi_hol_eles = element.findall('opinion_holder')
+	  if len(opi_hol_eles)!=0:
+		  opi_hol_ele = opi_hol_eles[0]
+		  tar_ids_hol = [t_ele.get('id') for t_ele in opi_hol_ele.findall('span/target')]
+	  
+	  #Target
+	  opi_tar_eles = element.findall('opinion_target')
+	  if len(opi_tar_eles) != 0:
+		opi_tar_ele = opi_tar_eles[0]
+		tar_ids_tar = [t_ele.get('id') for t_ele in opi_tar_ele.findall('span/target')]
+		
+	  ## Opinion expression
+	  opi_exp_eles = element.findall('opinion_expression')
+	  if len(opi_exp_eles) != 0:
+		  opi_exp_ele = opi_exp_eles[0]
+		  polarity = opi_exp_ele.get('polarity','')
+		  strength = opi_exp_ele.get('strength','')
+		  tar_ids_exp = [t_ele.get('id') for t_ele in opi_exp_ele.findall('span/target')]
+
+	  yield KafOpinion(my_id,tar_ids_hol, tar_ids_tar, KafOpinionExpression(polarity, strength,tar_ids_exp))	
+
+	
+