2 Words in Same Line

[mdorkhah]

Hi, I'm trying to find if two words from different types are in a same line. For lines I have annotation set as following:
doc.annset("Original markups").with_type("b")
I thought of something like this:

p = Or(Seq(Ann(name="tok1", type="typ1").overlapping(type="b", name="tok3"),Ann(name="tok2", type="typ2").overlapping(type="b", name="tok3")),
          Seq(Ann(name="tok2", type="typ2").overlapping(type="b", name="tok3"),Ann(name="tok1", type="typ1").overlapping(type="b", name="tok3")))
a1 = AddAnn(name="tok1", anntype="typ3")
a2 = AddAnn(name="tok2", anntype="typ4")
r = Rule(p,Actions(a1,a2))

But it's not working because overlapping has to argument name, so I don't know how to specify same line.

[johann-petrak]

This is something that is not supported by Pampac as it really is not a sequence pattern. Pampac supports checking is a metch occurs within an annotation but if the match itself is arbitrary and in any order this is not very efficient because it will check all possible pattern for being within some annotation.

It is probably much easier to have a separate annotator for this which does it the other way round: go over each b an check if it has both a typ1 and typ2 within it.

Your problem is a bit underspecified though: what if there are more than 1 annotation of typ1 and/or typ2? what if the typ1 and typ2 annotations overlap? Should both (or all) annotations just overlap with the same type "b" annotation or should they be fully contained with the same type "b" annotation? Can b annotations overlap or be contained within each other?

To find all typ1 and typ2 annotations where at least one annotation of each type is fully contained within a b annotation and be annotations do not overlap, something like this could be used:

(out of my head and untested)

def annotate_typ1typ2inb(annset):
    allbs = annset.with_type("b")
    alltyp1s = annset.with_type("typ1")
    alltyp2s = annset.with_type("typ2")
    for oneb in allbs:         
        typ1inb = alltyp1s.within(oneb)
        if len(typ1inb) == 0:
            continue
        typ2inb = alltyp2s.within(oneb)
        if len(typ2inb) == 0:
            continue
        for t1 in typ1inb:
            annset.add(t1, "typ3")
        for t2 in typ2inb:
            annset.add(t2, "typ4") 

Maybe this can be run as a separate annotator step, you can easily make an annotator out if this by creating an
Annotator callable:

class FindT1T2inB(Annotator):
    def __init__(self, insetname, outsetname):
        self.insetname = insetname
        self.outsetname = outsetname
    def __call__(self, doc, **kwargs):
        annset = doc.annset(self.insetname)
        outset = doc.annset(self.outsetname)
        allbs = annset.with_type("b")
        alltyp1s = annset.with_type("typ1")
        alltyp2s = annset.with_type("typ2")
        for oneb in allbs:         
            typ1inb = alltyp1s.within(oneb)
            if len(typ1inb) == 0:
                continue
            typ2inb = alltyp2s.within(oneb)
            if len(typ2inb) == 0:
                continue
            for t1 in typ1inb:
                outset.add(t1, "typ3")
            for t2 in typ2inb:
                outset.add(t2, "typ4")