improve udpipe.Base online=1

- bugfix: `model` was ignored when tokenize=0
- allow more combinations, e.g.
  tokenize=0 tag=1 parse=0 or
  tokenize=0 tag=0 parse=1
  where the existing tags/parses are reused
- for redoing the tokenization, you can use tokenize=1 delete_nodes=1
  which first deletes the existing nodes and then creates them again
  using UDPipe's tokenizer

Author: martinpopel

udapi/block/udpipe/base.py

@@ -120,12 +120,14 @@ class Base(Block):
 
     # pylint: disable=too-many-arguments
     def __init__(self, model=None, model_alias=None, online=False,
-                 tokenize=True, tag=True, parse=True, resegment=False, **kwargs):
+                 tokenize=True, tag=True, parse=True, resegment=False,
+                 delete_nodes=False, **kwargs):
         """Create the udpipe.En block object."""
         super().__init__(**kwargs)
         self.model, self.model_alias, self.online = model, model_alias, online
         self._tool = None
         self.tokenize, self.tag, self.parse, self.resegment = tokenize, tag, parse, resegment
+        self.delete_nodes = delete_nodes
 
     @property
     def tool(self):
@@ -146,16 +148,19 @@ def tool(self):
         return self._tool
 
     def process_document(self, doc):
-        tok, tag, par = self.tokenize, self.tag, self.parse
+        tok, tag, par, reseg = self.tokenize, self.tag, self.parse, self.resegment
         old_bundles = doc.bundles
         new_bundles = []
         for bundle in old_bundles:
             for tree in bundle:
                 new_bundles.append(bundle)
                 if self._should_process_tree(tree):
+                    if self.delete_nodes:
+                        for subroot in tree.children:
+                            subroot.remove()
                     if tok:
-                        new_trees = self.tool.tokenize_tag_parse_tree(tree, resegment=self.resegment,
-                                                                      tag=self.tag, parse=self.parse)
+                        new_trees = self.tool.tokenize_tag_parse_tree(tree, resegment=reseg,
+                                                                      tag=tag, parse=par)
                         if self.resegment and len(new_trees) > 1:
                             orig_bundle_id = bundle.bundle_id
                             bundle.bundle_id = orig_bundle_id + '-1'
@@ -164,9 +169,9 @@ def process_document(self, doc):
                                 new_tree.zone = tree.zone
                                 new_bundle.add_tree(new_tree)
                                 new_bundles.append(new_bundle)
-                    elif not tok and tag and par:
-                        self.tool.tag_parse_tree(tree)
-                    elif not tok and not tag and not par and self.resegment:
+                    elif not tok and not reseg and (tag or par):
+                        self.tool.tag_parse_tree(tree, tag=tag, parse=par)
+                    elif not tok and reseg and not tag and not par:
                         sentences = self.tool.segment_text(tree.text)
                         if len(sentences) > 1:
                             orig_bundle_id = bundle.bundle_id
@@ -178,7 +183,7 @@ def process_document(self, doc):
                                 new_tree.text = sentence
                                 new_bundles.append(new_bundle)
                     else:
-                        raise ValueError("Unimplemented tokenize=%s tag=%s parse=%s" % (tok, tag, par))
+                        raise ValueError(f"Unimplemented tokenize={tok} tag={tag} parse={par} resegment={reseg}")
         doc.bundles = new_bundles
 
 '''

udapi/tool/udpipeonline.py

@@ -62,21 +62,34 @@ def perform_request(self, params, method="process"):
 
         return response["result"]
 
-    def tag_parse_tree(self, root):
+    def tag_parse_tree(self, root, tag=True, parse=True):
         """Tag (+lemmatize, fill FEATS) and parse a tree (already tokenized)."""
+        if not tag and not parse:
+            raise ValueError('tag_parse_tree(root, tag=False, parse=False) does not make sense.')
         descendants = root.descendants
         if not descendants:
             return
         in_data = " ".join([n.form for n in descendants])
-        out_data = self.perform_request(params={"data": in_data, "input":"horizontal", "tagger":"", "parser":""})
-        conllu_reader = ConlluReader()
+        params = {"model": self.model, "data": in_data, "input":"horizontal", "tagger":""}
+        if tag:
+            attrs = 'upos xpos lemma feats'.split()
+        else:
+            attrs = []
+        if parse:
+            params["parser"] = ""
+            attrs.append('deprel')
+
+        out_data = self.perform_request(params=params)
+        conllu_reader = ConlluReader(empty_parent="ignore")
         conllu_reader.files.filehandle = io.StringIO(out_data)
         parsed_root = conllu_reader.read_tree()
-        root.flatten()
+        if parse:
+            root.flatten()
         for parsed_node in parsed_root.descendants:
             node = descendants[parsed_node.ord - 1]
-            node.parent = descendants[parsed_node.parent.ord - 1] if parsed_node.parent.ord else root
-            for attr in 'upos xpos lemma feats deprel'.split():
+            if parse:
+                node.parent = descendants[parsed_node.parent.ord - 1] if parsed_node.parent.ord else root
+            for attr in attrs:
                 setattr(node, attr, getattr(parsed_node, attr))
 
     def tokenize_tag_parse_tree(self, root, resegment=False, tag=True, parse=True):